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 queryLookahead(SGTimeStamp& timeStamp)
 391     {
 392         RTIfedTime fedTime;
 393         _rtiAmbassador.queryLookahead(fedTime);
 394         timeStamp = toTimeStamp(fedTime);
 395     }
 396
 397     RTI13ObjectClass* createObjectClass(const std::string& name, HLAObjectClass* hlaObjectClass)
 398     {
 399         RTI::ObjectClassHandle objectClassHandle;
 400         objectClassHandle = getObjectClassHandle(name);
 401         if (_objectClassMap.find(objectClassHandle) != _objectClassMap.end()) {
 402             SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not create object class, object class already exists!");
 403             return 0;
 404         }
 405         RTI13ObjectClass* rtiObjectClass;
 406         rtiObjectClass = new RTI13ObjectClass(hlaObjectClass, objectClassHandle, this);
 407         _objectClassMap[objectClassHandle] = rtiObjectClass;
 408         return rtiObjectClass;
 409     }
 410     RTI::ObjectClassHandle getObjectClassHandle(const std::string& name)
 411     { return _rtiAmbassador.getObjectClassHandle(name.c_str()); }
 412     std::string getObjectClassName(const RTI::ObjectClassHandle& handle)
 413     { return rtiToStdString(_rtiAmbassador.getObjectClassName(handle)); }
 414
 415     RTI::AttributeHandle getAttributeHandle(const std::string& attributeName, const RTI::ObjectClassHandle& objectClassHandle)
 416     { return _rtiAmbassador.getAttributeHandle(attributeName.c_str(), objectClassHandle); }
 417     std::string getAttributeName(const RTI::AttributeHandle& attributeHandle, const RTI::ObjectClassHandle& objectClassHandle)
 418     { return rtiToStdString(_rtiAmbassador.getAttributeName(attributeHandle, objectClassHandle)); }
 419
 420     // RTIHandle getInteractionClassHandle(const std::string& name)
 421     // {
 422     //     try {
 423     //         return _rtiAmbassador.getInteractionClassHandle(name.c_str());
 424     //     } catch (RTI::NameNotFound& e) {
 425     //     } catch (RTI::FederateNotExecutionMember& e) {
 426     //     } catch (RTI::ConcurrentAccessAttempted& e) {
 427     //     } catch (RTI::RTIinternalError& e) {
 428     //     }
 429     //     return RTIHandle(-1);
 430     // }
 431     // std::string getInteractionClassName(const RTIHandle& handle)
 432     // {
 433     //     std::string name;
 434     //     try {
 435     //         rtiToStdString(name, _rtiAmbassador.getInteractionClassName(handle));
 436     //     } catch (RTI::InteractionClassNotDefined& e) {
 437     //     } catch (RTI::FederateNotExecutionMember& e) {
 438     //     } catch (RTI::ConcurrentAccessAttempted& e) {
 439     //     } catch (RTI::RTIinternalError& e) {
 440     //     }
 441     //     return name;
 442     // }
 443
 444     // RTIHandle getParameterHandle(const std::string& parameterName, const RTIHandle& interactionClassHandle)
 445     // {
 446     //     try {
 447     //         return _rtiAmbassador.getParameterHandle(parameterName.c_str(), interactionClassHandle);
 448     //     } catch (RTI::InteractionClassNotDefined& e) {
 449     //     } catch (RTI::NameNotFound& e) {
 450     //     } catch (RTI::FederateNotExecutionMember& e) {
 451     //     } catch (RTI::ConcurrentAccessAttempted& e) {
 452     //     } catch (RTI::RTIinternalError& e) {
 453     //     }
 454     //     return RTIHandle(-1);
 455     // }
 456     // std::string getParameterName(const RTIHandle& parameterHandle, const RTIHandle& interactionClassHandle)
 457     // {
 458     //     std::string parameterName;
 459     //     try {
 460     //         rtiToStdString(parameterName, _rtiAmbassador.getParameterName(parameterHandle, interactionClassHandle));
 461     //     } catch (RTI::InteractionClassNotDefined& e) {
 462     //     } catch (RTI::InteractionParameterNotDefined& e) {
 463     //     } catch (RTI::FederateNotExecutionMember& e) {
 464     //     } catch (RTI::ConcurrentAccessAttempted& e) {
 465     //     } catch (RTI::RTIinternalError& e) {
 466     //     }
 467     //     return parameterName;
 468     // }
 469
 470     RTI13ObjectInstance* getObjectInstance(const std::string& name)
 471     {
 472         RTI::ObjectHandle objectHandle;
 473         objectHandle = getObjectInstanceHandle(name);
 474         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 475         if (i == _objectInstanceMap.end()) {
 476             SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: ObjectInstance not found.");
 477             return 0;
 478         }
 479         return i->second;
 480     }
 481     RTI::ObjectHandle getObjectInstanceHandle(const std::string& name)
 482     { return _rtiAmbassador.getObjectInstanceHandle(name.c_str()); }
 483     std::string getObjectInstanceName(const RTI::ObjectHandle& objectHandle)
 484     { return rtiToStdString(_rtiAmbassador.getObjectInstanceName(objectHandle)); }
 485
 486     // RTIHandle getRoutingSpaceHandle(const std::string& routingSpaceName)
 487     // {
 488     //     try {
 489     //         return _rtiAmbassador.getRoutingSpaceHandle(routingSpaceName.c_str());
 490     //     } catch (RTI::NameNotFound& e) {
 491     //     } catch (RTI::FederateNotExecutionMember& e) {
 492     //     } catch (RTI::ConcurrentAccessAttempted& e) {
 493     //     } catch (RTI::RTIinternalError& e) {
 494     //     }
 495     //     return RTIHandle(-1);
 496     // }
 497     // std::string getRoutingSpaceName(const RTIHandle& routingSpaceHandle)
 498     // {
 499     //     std::string routingSpaceName;
 500     //     try {
 501     //         rtiToStdString(routingSpaceName, _rtiAmbassador.wgetRoutingSpaceName(routingSpaceHandle));
 502     //     } catch (RTI::SpaceNotDefined& e) {
 503     //     } catch (RTI::FederateNotExecutionMember& e) {
 504     //     } catch (RTI::ConcurrentAccessAttempted& e) {
 505     //     } catch (RTI::RTIinternalError& e) {
 506     //     }
 507     //     return routingSpaceName;
 508     // }
 509
 510     void enableClassRelevanceAdvisorySwitch()
 511     { _rtiAmbassador.enableClassRelevanceAdvisorySwitch(); }
 512     void disableClassRelevanceAdvisorySwitch()
 513     { _rtiAmbassador.disableClassRelevanceAdvisorySwitch(); }
 514
 515     void enableAttributeRelevanceAdvisorySwitch()
 516     { _rtiAmbassador.enableAttributeRelevanceAdvisorySwitch(); }
 517     void disableAttributeRelevanceAdvisorySwitch()
 518     { _rtiAmbassador.disableAttributeRelevanceAdvisorySwitch(); }
 519
 520     void enableAttributeScopeAdvisorySwitch()
 521     { _rtiAmbassador.enableAttributeScopeAdvisorySwitch(); }
 522     void disableAttributeScopeAdvisorySwitch()
 523     { _rtiAmbassador.disableAttributeScopeAdvisorySwitch(); }
 524
 525     void enableInteractionRelevanceAdvisorySwitch()
 526     { _rtiAmbassador.enableInteractionRelevanceAdvisorySwitch(); }
 527     void disableInteractionRelevanceAdvisorySwitch()
 528     { _rtiAmbassador.disableInteractionRelevanceAdvisorySwitch(); }
 529
 530
 531     bool tick()
 532     { return _rtiAmbassador.tick(); }
 533     bool tick(double minimum, double maximum)
 534     { return _rtiAmbassador.tick(minimum, maximum); }
 535
 536     void addObjectInstanceForCallback(RTIObjectInstance* objectIntance)
 537     { _objectInstancePendingCallbackList.insert(objectIntance); }
 538
 539 private:
 540     /// Generic callback to execute some notification on objects in a way that they are not prone to
 541     /// ConcurrentAccess exceptions.
 542     class QueueCallback : public SGReferenced {
 543     public:
 544         virtual ~QueueCallback() {}
 545         virtual void operator()() = 0;
 546     };
 547
 548     class RemoveObjectCallback : public QueueCallback {
 549     public:
 550         RemoveObjectCallback(SGSharedPtr<RTIObjectInstance> objectInstance, const RTIData& tag) :
 551             _objectInstance(objectInstance),
 552             _tag(tag)
 553         { }
 554         virtual void operator()()
 555         {
 556             _objectInstance->removeInstance(_tag);
 557         }
 558     private:
 559         SGSharedPtr<RTIObjectInstance> _objectInstance;
 560         RTIData _tag;
 561     };
 562
 563     /// Just the interface class doing the callbacks into the parent class
 564     struct FederateAmbassador : public RTI::FederateAmbassador {
 565         FederateAmbassador(RTI13Ambassador& rtiAmbassador) :
 566             _rtiAmbassador(rtiAmbassador)
 567         {
 568         }
 569         virtual ~FederateAmbassador()
 570         throw (RTI::FederateInternalError)
 571         {
 572         }
 573
 574         /// RTI federate ambassador callback functions.
 575         virtual void synchronizationPointRegistrationSucceeded(const char* label)
 576             throw (RTI::FederateInternalError)
 577         {
 578         }
 579
 580         virtual void synchronizationPointRegistrationFailed(const char* label)
 581             throw (RTI::FederateInternalError)
 582         {
 583         }
 584
 585         virtual void announceSynchronizationPoint(const char* label, const char* tag)
 586             throw (RTI::FederateInternalError)
 587         {
 588             _rtiAmbassador._pendingSyncLabels.insert(toStdString(label));
 589         }
 590
 591         virtual void federationSynchronized(const char* label)
 592             throw (RTI::FederateInternalError)
 593         {
 594             std::string s = toStdString(label);
 595             _rtiAmbassador._pendingSyncLabels.erase(s);
 596             _rtiAmbassador._syncronizedSyncLabels.insert(s);
 597         }
 598
 599         virtual void initiateFederateSave(const char* label)
 600             throw (RTI::UnableToPerformSave,
 601                    RTI::FederateInternalError)
 602         {
 603         }
 604
 605         virtual void federationSaved()
 606             throw (RTI::FederateInternalError)
 607         {
 608         }
 609
 610         virtual void federationNotSaved()
 611             throw (RTI::FederateInternalError)
 612         {
 613         }
 614
 615         virtual void requestFederationRestoreSucceeded(const char* label)
 616             throw (RTI::FederateInternalError)
 617         {
 618         }
 619
 620         virtual void requestFederationRestoreFailed(const char* label, const char* reason)
 621             throw (RTI::FederateInternalError)
 622         {
 623         }
 624
 625         virtual void federationRestoreBegun()
 626             throw (RTI::FederateInternalError)
 627         {
 628         }
 629
 630         virtual void initiateFederateRestore(const char* label, RTI::FederateHandle federateHandle)
 631             throw (RTI::SpecifiedSaveLabelDoesNotExist,
 632                    RTI::CouldNotRestore,
 633                    RTI::FederateInternalError)
 634         {
 635         }
 636
 637         virtual void federationRestored()
 638             throw (RTI::FederateInternalError)
 639         {
 640         }
 641
 642         virtual void federationNotRestored()
 643             throw (RTI::FederateInternalError)
 644         {
 645         }
 646
 647         // Declaration Management
 648         virtual void startRegistrationForObjectClass(RTI::ObjectClassHandle objectClassHandle)
 649             throw (RTI::ObjectClassNotPublished,
 650                    RTI::FederateInternalError)
 651         {
 652             ObjectClassMap::iterator i = _rtiAmbassador._objectClassMap.find(objectClassHandle);
 653             if (i == _rtiAmbassador._objectClassMap.end())
 654                 return;
 655             if (!i->second.valid())
 656                 return;
 657             i->second->startRegistration();
 658         }
 659
 660         virtual void stopRegistrationForObjectClass(RTI::ObjectClassHandle objectClassHandle)
 661             throw (RTI::ObjectClassNotPublished,
 662                    RTI::FederateInternalError)
 663         {
 664             ObjectClassMap::iterator i = _rtiAmbassador._objectClassMap.find(objectClassHandle);
 665             if (i == _rtiAmbassador._objectClassMap.end())
 666                 return;
 667             if (!i->second.valid())
 668                 return;
 669             i->second->stopRegistration();
 670         }
 671
 672         virtual void turnInteractionsOn(RTI::InteractionClassHandle interactionClassHandle)
 673             throw (RTI::InteractionClassNotPublished,
 674                    RTI::FederateInternalError)
 675         {
 676         }
 677
 678         virtual void turnInteractionsOff(RTI::InteractionClassHandle interactionClassHandle)
 679             throw (RTI::InteractionClassNotPublished,
 680                    RTI::FederateInternalError)
 681         {
 682         }
 683
 684
 685         // Object Management
 686         virtual void discoverObjectInstance(RTI::ObjectHandle objectHandle, RTI::ObjectClassHandle objectClassHandle, const char* tag)
 687             throw (RTI::CouldNotDiscover,
 688                    RTI::ObjectClassNotKnown,
 689                    RTI::FederateInternalError)
 690         {
 691             ObjectClassMap::iterator i = _rtiAmbassador._objectClassMap.find(objectClassHandle);
 692             if (i == _rtiAmbassador._objectClassMap.end())
 693                 throw RTI::ObjectClassNotKnown("Federate: discoverObjectInstance()!");
 694             if (!i->second.valid())
 695                 return;
 696             SGSharedPtr<RTI13ObjectInstance> objectInstance = new RTI13ObjectInstance(objectHandle, 0, i->second, &_rtiAmbassador, false);
 697             _rtiAmbassador._objectInstanceMap[objectHandle] = objectInstance;
 698             _rtiAmbassador._objectInstancePendingCallbackList.insert(objectInstance);
 699             i->second->discoverInstance(objectInstance.get(), tagToData(tag));
 700         }
 701
 702         virtual void reflectAttributeValues(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleValuePairSet& attributeValuePairSet,
 703                                             const RTI::FedTime& fedTime, const char* tag, RTI::EventRetractionHandle eventRetractionHandle)
 704             throw (RTI::ObjectNotKnown,
 705                    RTI::AttributeNotKnown,
 706                    RTI::FederateOwnsAttributes,
 707                    RTI::InvalidFederationTime,
 708                    RTI::FederateInternalError)
 709         {
 710             ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
 711             if (i == _rtiAmbassador._objectInstanceMap.end())
 712                 throw RTI::ObjectNotKnown("Reflect attributes for unknown object!");
 713             if (!i->second.valid())
 714                 return;
 715             i->second->reflectAttributeValues(attributeValuePairSet, toTimeStamp(fedTime), tagToData(tag));
 716         }
 717
 718         virtual void reflectAttributeValues(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleValuePairSet& attributeValuePairSet,
 719                                             const char* tag)
 720             throw (RTI::ObjectNotKnown,
 721                    RTI::AttributeNotKnown,
 722                    RTI::FederateOwnsAttributes,
 723                    RTI::FederateInternalError)
 724         {
 725             ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
 726             if (i == _rtiAmbassador._objectInstanceMap.end())
 727                 throw RTI::ObjectNotKnown("Reflect attributes for unknown object!");
 728             if (!i->second.valid())
 729                 return;
 730             i->second->reflectAttributeValues(attributeValuePairSet, tagToData(tag));
 731         }
 732
 733         virtual void receiveInteraction(RTI::InteractionClassHandle interactionClassHandle, const RTI::ParameterHandleValuePairSet& parameters,
 734                                         const RTI::FedTime& fedTime, const char* tag, RTI::EventRetractionHandle eventRetractionHandle)
 735             throw (RTI::InteractionClassNotKnown,
 736                    RTI::InteractionParameterNotKnown,
 737                    RTI::InvalidFederationTime,
 738                    RTI::FederateInternalError)
 739         {
 740         }
 741
 742         virtual void receiveInteraction(RTI::InteractionClassHandle interactionClassHandle,
 743                                         const RTI::ParameterHandleValuePairSet& parameters, const char* tag)
 744             throw (RTI::InteractionClassNotKnown,
 745                    RTI::InteractionParameterNotKnown,
 746                    RTI::FederateInternalError)
 747         {
 748         }
 749
 750         virtual void removeObjectInstance(RTI::ObjectHandle objectHandle, const RTI::FedTime& fedTime,
 751                                           const char* tag, RTI::EventRetractionHandle eventRetractionHandle)
 752             throw (RTI::ObjectNotKnown,
 753                    RTI::InvalidFederationTime,
 754                    RTI::FederateInternalError)
 755         {
 756             ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
 757             if (i == _rtiAmbassador._objectInstanceMap.end())
 758                 throw RTI::ObjectNotKnown("Federate: removeObjectInstance()!");
 759             if (i->second.valid())
 760                 _rtiAmbassador._queueCallbackList.push_back(new RemoveObjectCallback(i->second, tagToData(tag)));
 761             _rtiAmbassador._objectInstancePendingCallbackList.erase(i->second);
 762             _rtiAmbassador._objectInstanceMap.erase(i);
 763         }
 764
 765         virtual void removeObjectInstance(RTI::ObjectHandle objectHandle, const char* tag)
 766             throw (RTI::ObjectNotKnown,
 767                    RTI::FederateInternalError)
 768         {
 769             ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
 770             if (i == _rtiAmbassador._objectInstanceMap.end())
 771                 throw RTI::ObjectNotKnown("Federate: removeObjectInstance()!");
 772             if (i->second.valid())
 773                 _rtiAmbassador._queueCallbackList.push_back(new RemoveObjectCallback(i->second, tagToData(tag)));
 774             _rtiAmbassador._objectInstancePendingCallbackList.erase(i->second);
 775             _rtiAmbassador._objectInstanceMap.erase(i);
 776         }
 777
 778         virtual void attributesInScope(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
 779             throw (RTI::ObjectNotKnown,
 780                    RTI::AttributeNotKnown,
 781                    RTI::FederateInternalError)
 782         {
 783             ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
 784             if (i == _rtiAmbassador._objectInstanceMap.end())
 785                 throw RTI::ObjectNotKnown("Attributes in scope for unknown object!");
 786             if (!i->second.valid())
 787                 return;
 788             i->second->attributesInScope(attributes);
 789         }
 790
 791         virtual void attributesOutOfScope(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
 792             throw (RTI::ObjectNotKnown,
 793                    RTI::AttributeNotKnown,
 794                    RTI::FederateInternalError)
 795         {
 796             ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
 797             if (i == _rtiAmbassador._objectInstanceMap.end())
 798                 throw RTI::ObjectNotKnown("Attributes in scope for unknown object!");
 799             if (!i->second.valid())
 800                 return;
 801             i->second->attributesOutOfScope(attributes);
 802         }
 803
 804         virtual void provideAttributeValueUpdate(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
 805             throw (RTI::ObjectNotKnown,
 806                    RTI::AttributeNotKnown,
 807                    RTI::AttributeNotOwned,
 808                    RTI::FederateInternalError)
 809         {
 810             ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
 811             if (i == _rtiAmbassador._objectInstanceMap.end())
 812                 throw RTI::ObjectNotKnown("Reflect attributes for unknown object!");
 813             if (!i->second.valid())
 814                 return;
 815             i->second->provideAttributeValueUpdate(attributes);
 816         }
 817
 818         virtual void turnUpdatesOnForObjectInstance(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
 819             throw (RTI::ObjectNotKnown,
 820                    RTI::AttributeNotOwned,
 821                    RTI::FederateInternalError)
 822         {
 823             ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
 824             if (i == _rtiAmbassador._objectInstanceMap.end())
 825                 throw RTI::ObjectNotKnown("Turn on attributes for unknown object!");
 826             if (!i->second.valid())
 827                 return;
 828             i->second->turnUpdatesOnForObjectInstance(attributes);
 829         }
 830
 831         virtual void turnUpdatesOffForObjectInstance(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
 832             throw (RTI::ObjectNotKnown,
 833                    RTI::AttributeNotOwned,
 834                    RTI::FederateInternalError)
 835         {
 836             ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
 837             if (i == _rtiAmbassador._objectInstanceMap.end())
 838                 throw RTI::ObjectNotKnown("Turn off attributes for unknown object!");
 839             if (!i->second.valid())
 840                 return;
 841             i->second->turnUpdatesOffForObjectInstance(attributes);
 842         }
 843
 844         // Ownership Management
 845         virtual void requestAttributeOwnershipAssumption(RTI::ObjectHandle objectHandle,
 846                                                          const RTI::AttributeHandleSet& attributes, const char* tag)
 847             throw (RTI::ObjectNotKnown,
 848                    RTI::AttributeNotKnown,
 849                    RTI::AttributeAlreadyOwned,
 850                    RTI::AttributeNotPublished,
 851                    RTI::FederateInternalError)
 852         {
 853             ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
 854             if (i == _rtiAmbassador._objectInstanceMap.end())
 855                 throw RTI::ObjectNotKnown("requestAttributeOwnershipAssumption for unknown object!");
 856             if (!i->second.valid())
 857                 return;
 858             i->second->requestAttributeOwnershipAssumption(attributes, tagToData(tag));
 859         }
 860
 861         virtual void attributeOwnershipDivestitureNotification(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
 862             throw (RTI::ObjectNotKnown,
 863                    RTI::AttributeNotKnown,
 864                    RTI::AttributeNotOwned,
 865                    RTI::AttributeDivestitureWasNotRequested,
 866                    RTI::FederateInternalError)
 867         {
 868             ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
 869             if (i == _rtiAmbassador._objectInstanceMap.end())
 870                 throw RTI::ObjectNotKnown("attributeOwnershipDivestitureNotification for unknown object!");
 871             if (!i->second.valid())
 872                 return;
 873             i->second->attributeOwnershipDivestitureNotification(attributes);
 874         }
 875
 876         virtual void attributeOwnershipAcquisitionNotification(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
 877             throw (RTI::ObjectNotKnown,
 878                    RTI::AttributeNotKnown,
 879                    RTI::AttributeAcquisitionWasNotRequested,
 880                    RTI::AttributeAlreadyOwned,
 881                    RTI::AttributeNotPublished,
 882                    RTI::FederateInternalError)
 883         {
 884             ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
 885             if (i == _rtiAmbassador._objectInstanceMap.end())
 886                 throw RTI::ObjectNotKnown("attributeOwnershipAcquisitionNotification for unknown object!");
 887             if (!i->second.valid())
 888                 return;
 889             i->second->attributeOwnershipAcquisitionNotification(attributes);
 890         }
 891
 892         virtual void attributeOwnershipUnavailable(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
 893             throw (RTI::ObjectNotKnown,
 894                    RTI::AttributeNotKnown,
 895                    RTI::AttributeAlreadyOwned,
 896                    RTI::AttributeAcquisitionWasNotRequested,
 897                    RTI::FederateInternalError)
 898         {
 899             ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
 900             if (i == _rtiAmbassador._objectInstanceMap.end())
 901                 throw RTI::ObjectNotKnown("attributeOwnershipUnavailable for unknown object!");
 902             if (!i->second.valid())
 903                 return;
 904             i->second->attributeOwnershipUnavailable(attributes);
 905         }
 906
 907         virtual void requestAttributeOwnershipRelease(RTI::ObjectHandle objectHandle,
 908                                                       const RTI::AttributeHandleSet& attributes, const char* tag)
 909             throw (RTI::ObjectNotKnown,
 910                    RTI::AttributeNotKnown,
 911                    RTI::AttributeNotOwned,
 912                    RTI::FederateInternalError)
 913         {
 914             ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
 915             if (i == _rtiAmbassador._objectInstanceMap.end())
 916                 throw RTI::ObjectNotKnown("requestAttributeOwnershipRelease for unknown object!");
 917             if (!i->second.valid())
 918                 return;
 919             i->second->requestAttributeOwnershipRelease(attributes, tagToData(tag));
 920         }
 921
 922         virtual void confirmAttributeOwnershipAcquisitionCancellation(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
 923             throw (RTI::ObjectNotKnown,
 924                    RTI::AttributeNotKnown,
 925                    RTI::AttributeAlreadyOwned,
 926                    RTI::AttributeAcquisitionWasNotCanceled,
 927                    RTI::FederateInternalError)
 928         {
 929             ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
 930             if (i == _rtiAmbassador._objectInstanceMap.end())
 931                 throw RTI::ObjectNotKnown("confirmAttributeOwnershipAcquisitionCancellation for unknown object!");
 932             if (!i->second.valid())
 933                 return;
 934             i->second->confirmAttributeOwnershipAcquisitionCancellation(attributes);
 935         }
 936
 937         virtual void informAttributeOwnership(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle,
 938                                               RTI::FederateHandle federateHandle)
 939             throw (RTI::ObjectNotKnown,
 940                    RTI::AttributeNotKnown,
 941                    RTI::FederateInternalError)
 942         {
 943             ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
 944             if (i == _rtiAmbassador._objectInstanceMap.end())
 945                 throw RTI::ObjectNotKnown("informAttributeOwnership for unknown object!");
 946             if (!i->second.valid())
 947                 return;
 948             i->second->informAttributeOwnership(attributeHandle, federateHandle);
 949         }
 950
 951         virtual void attributeIsNotOwned(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle)
 952             throw (RTI::ObjectNotKnown,
 953                    RTI::AttributeNotKnown,
 954                    RTI::FederateInternalError)
 955         {
 956             ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
 957             if (i == _rtiAmbassador._objectInstanceMap.end())
 958                 throw RTI::ObjectNotKnown("attributeIsNotOwned for unknown object!");
 959             if (!i->second.valid())
 960                 return;
 961             i->second->attributeIsNotOwned(attributeHandle);
 962         }
 963
 964         virtual void attributeOwnedByRTI(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle)
 965             throw (RTI::ObjectNotKnown,
 966                    RTI::AttributeNotKnown,
 967                    RTI::FederateInternalError)
 968         {
 969             ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
 970             if (i == _rtiAmbassador._objectInstanceMap.end())
 971                 throw RTI::ObjectNotKnown("attributeOwnedByRTI for unknown object!");
 972             if (!i->second.valid())
 973                 return;
 974             i->second->attributeOwnedByRTI(attributeHandle);
 975         }
 976
 977         // Time Management
 978         virtual void timeRegulationEnabled(const RTI::FedTime& fedTime)
 979             throw (RTI::InvalidFederationTime,
 980                    RTI::EnableTimeRegulationWasNotPending,
 981                    RTI::FederateInternalError)
 982         {
 983             _rtiAmbassador._timeRegulationEnabled = true;
 984             _rtiAmbassador._federateTime = toTimeStamp(fedTime);
 985             SG_LOG(SG_NETWORK, SG_INFO, "RTI: timeRegulationEnabled: " << _rtiAmbassador._federateTime);
 986         }
 987
 988         virtual void timeConstrainedEnabled(const RTI::FedTime& fedTime)
 989             throw (RTI::InvalidFederationTime,
 990                    RTI::EnableTimeConstrainedWasNotPending,
 991                    RTI::FederateInternalError)
 992         {
 993             _rtiAmbassador._timeConstrainedEnabled = true;
 994             _rtiAmbassador._federateTime = toTimeStamp(fedTime);
 995             SG_LOG(SG_NETWORK, SG_INFO, "RTI: timeConstrainedEnabled: " << _rtiAmbassador._federateTime);
 996         }
 997
 998         virtual void timeAdvanceGrant(const RTI::FedTime& fedTime)
 999             throw (RTI::InvalidFederationTime,
1000                    RTI::TimeAdvanceWasNotInProgress,
1001                    RTI::FederateInternalError)
1002         {
1003             _rtiAmbassador._federateTime = toTimeStamp(fedTime);
1004             _rtiAmbassador._timeAdvancePending = false;
1005             SG_LOG(SG_NETWORK, SG_INFO, "RTI: timeAdvanceGrant: " << _rtiAmbassador._federateTime);
1006         }
1007
1008         virtual void requestRetraction(RTI::EventRetractionHandle eventRetractionHandle)
1009             throw (RTI::EventNotKnown,
1010                    RTI::FederateInternalError)
1011         {
1012             // No retraction concept yet
1013         }
1014
1015     private:
1016         const RTIData& tagToData(const char* tag)
1017         {
1018             if (tag)
1019                 _cachedTag.setData(tag, std::strlen(tag) + 1);
1020             else
1021                 _cachedTag.setData("", 1);
1022             return _cachedTag;
1023         }
1024         RTIData _cachedTag;
1025
1026         RTI13Ambassador& _rtiAmbassador;
1027     };
1028
1029     static SGTimeStamp toTimeStamp(const RTI::FedTime& fedTime)
1030     {
1031         RTIfedTime referenceTime(fedTime);
1032         return SGTimeStamp::fromSec(referenceTime.getTime() + 0.5e-9);
1033     }
1034
1035     static RTIfedTime toFedTime(const SGTimeStamp& timeStamp)
1036     {
1037         RTIfedTime referenceTime;
1038         referenceTime.setZero();
1039         referenceTime += timeStamp.toSecs();
1040         return referenceTime;
1041     }
1042
1043     static std::string rtiToStdString(char* n)
1044     {
1045         if (!n)
1046             return std::string();
1047         std::string s;
1048         s.assign(n);
1049         delete[] n;
1050         return s;
1051     }
1052
1053     static std::string toStdString(const char* n)
1054     {
1055         if (!n)
1056             return std::string();
1057         return std::string(n);
1058     }
1059
1060     // The connection class
1061     RTI::RTIambassador _rtiAmbassador;
1062
1063     // The class with all the callbacks.
1064     FederateAmbassador _federateAmbassador;
1065
1066     // All the sync labels we got an announcement for
1067     std::set<std::string> _pendingSyncLabels;
1068     std::set<std::string> _syncronizedSyncLabels;
1069
1070     // All that calls back into user code is just queued.
1071     // That is to make sure we do not call recursively into the RTI
1072     typedef std::list<SGSharedPtr<QueueCallback> > QueueCallbackList;
1073     QueueCallbackList _queueCallbackList;
1074     // All object instances that need to be called due to some event are noted here
1075     // That is to make sure we do not call recursively into the RTI
1076     typedef std::set<SGSharedPtr<RTIObjectInstance> > ObjectInstanceSet;
1077     ObjectInstanceSet _objectInstancePendingCallbackList;
1078
1079     // Top level information for dispatching federate object attribute updates
1080     typedef std::map<RTI::ObjectHandle, SGSharedPtr<RTI13ObjectInstance> > ObjectInstanceMap;
1081     // Map of all available objects
1082     ObjectInstanceMap _objectInstanceMap;
1083
1084     // Top level information for dispatching creation of federate objects
1085     typedef std::map<RTI::ObjectClassHandle, SGSharedPtr<RTI13ObjectClass> > ObjectClassMap;
1086     ObjectClassMap _objectClassMap;
1087
1088     bool _timeRegulationEnabled;
1089     bool _timeConstrainedEnabled;
1090     bool _timeAdvancePending;
1091     SGTimeStamp _federateTime;
1092 };
1093
1094 } // namespace simgear
1095
1096 #endif