1 // Copyright (C) 2009 - 2010 Mathias Froehlich - Mathias.Froehlich@web.de
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.
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.
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.
18 #ifndef RTIAmbassador_hxx
19 #define RTIAmbassador_hxx
28 #ifndef RTI_USES_STD_FSTREAM
29 #define RTI_USES_STD_FSTREAM
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>
41 #include "RTIObjectClass.hxx"
42 #include "RTIData.hxx"
43 #include "RTI13Federate.hxx"
44 #include "RTI13ObjectInstance.hxx"
48 class RTI13Ambassador : public SGWeakReferenced {
51 _federateAmbassador(*this),
52 _timeRegulationEnabled(false),
53 _timeConstrainedEnabled(false),
54 _timeAdvancePending(false)
56 virtual ~RTI13Ambassador()
59 // processes the queues that filled up during the past
62 while (!_queueCallbackList.empty()) {
63 (*_queueCallbackList.front())();
64 _queueCallbackList.pop_front();
67 while (!_objectInstancePendingCallbackList.empty()) {
68 (*_objectInstancePendingCallbackList.begin())->flushPendingRequests();
69 _objectInstancePendingCallbackList.erase(_objectInstancePendingCallbackList.begin());
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; }
82 bool getFederationSynchronizationPointAnnounced(const std::string& label)
83 { return _pendingSyncLabels.find(label) != _pendingSyncLabels.end(); }
84 bool getFederationSynchronized(const std::string& label)
86 std::set<std::string>::iterator i = _syncronizedSyncLabels.find(label);
87 if (i == _syncronizedSyncLabels.end())
89 _syncronizedSyncLabels.erase(i);
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()); }
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); }
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()); }
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); }
117 RTI13ObjectInstance* registerObjectInstance(const RTI13ObjectClass* objectClass, HLAObjectInstance* hlaObjectInstance)
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;
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()); }
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()); }
135 void deleteObjectInstance(const RTI::ObjectHandle& objectHandle, const SGTimeStamp& timeStamp, const RTIData& tag)
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.");
143 _objectInstancePendingCallbackList.erase(i->second);
144 _objectInstanceMap.erase(i);
146 void deleteObjectInstance(const RTI::ObjectHandle& objectHandle, const RTIData& tag)
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.");
154 _objectInstancePendingCallbackList.erase(i->second);
155 _objectInstanceMap.erase(i);
157 void localDeleteObjectInstance(const RTI::ObjectHandle& objectHandle)
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.");
165 _objectInstancePendingCallbackList.erase(i->second);
166 _objectInstanceMap.erase(i);
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); }
174 // Ownership Management -------------------
176 // bool unconditionalAttributeOwnershipDivestiture(const RTIHandle& objectHandle, const RTIHandleSet& attributeHandles)
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);
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) {
195 // bool negotiatedAttributeOwnershipDivestiture(const RTIHandle& objectHandle, const RTIHandleSet& attributeHandles, const RTIData& tag)
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());
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) {
215 // bool attributeOwnershipAcquisition(const RTIHandle& objectHandle, const RTIHandleSet& attributeHandles, const RTIData& tag)
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());
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) {
236 // bool attributeOwnershipAcquisitionIfAvailable(const RTIHandle& objectHandle, const RTIHandleSet& attributeHandles)
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);
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) {
258 // RTIHandleSet attributeOwnershipReleaseResponse(const RTIHandle& objectHandle, const RTIHandleSet& attributeHandles)
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));
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) {
280 // return RTIHandleSet();
282 // bool cancelNegotiatedAttributeOwnershipDivestiture(const RTIHandle& objectHandle, const RTIHandleSet& attributeHandles)
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);
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) {
302 // bool cancelAttributeOwnershipAcquisition(const RTIHandle& objectHandle, const RTIHandleSet& attributeHandles)
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);
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) {
322 // bool queryAttributeOwnership(const RTIHandle& objectHandle, const RTIHandle& attributeHandle)
325 // _rtiAmbassador.queryAttributeOwnership(objectHandle, attributeHandle);
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) {
337 // bool isAttributeOwnedByFederate(const RTIHandle& objectHandle, const RTIHandle& attributeHandle)
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) {
354 void enableTimeRegulation(const SGTimeStamp& federateTime, const SGTimeStamp& lookahead)
355 { _rtiAmbassador.enableTimeRegulation(toFedTime(federateTime), toFedTime(lookahead)); }
356 void disableTimeRegulation()
357 { _rtiAmbassador.disableTimeRegulation(); _timeRegulationEnabled = false; }
359 void enableTimeConstrained()
360 { _rtiAmbassador.enableTimeConstrained(); }
361 void disableTimeConstrained()
362 { _rtiAmbassador.disableTimeConstrained(); _timeConstrainedEnabled = false; }
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; }
369 // bool queryLBTS(double& time)
372 // RTIfedTime fedTime;
373 // _rtiAmbassador.queryLBTS(fedTime);
374 // time = fedTime.getTime();
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) {
384 void queryFederateTime(SGTimeStamp& timeStamp)
387 _rtiAmbassador.queryFederateTime(fedTime);
388 timeStamp = toTimeStamp(fedTime);
390 void queryLookahead(SGTimeStamp& timeStamp)
393 _rtiAmbassador.queryLookahead(fedTime);
394 timeStamp = toTimeStamp(fedTime);
397 RTI13ObjectClass* createObjectClass(const std::string& name, HLAObjectClass* hlaObjectClass)
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!");
405 RTI13ObjectClass* rtiObjectClass;
406 rtiObjectClass = new RTI13ObjectClass(hlaObjectClass, objectClassHandle, this);
407 _objectClassMap[objectClassHandle] = rtiObjectClass;
408 return rtiObjectClass;
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)); }
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)); }
420 // RTIHandle getInteractionClassHandle(const std::string& name)
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) {
429 // return RTIHandle(-1);
431 // std::string getInteractionClassName(const RTIHandle& handle)
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) {
444 // RTIHandle getParameterHandle(const std::string& parameterName, const RTIHandle& interactionClassHandle)
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) {
454 // return RTIHandle(-1);
456 // std::string getParameterName(const RTIHandle& parameterHandle, const RTIHandle& interactionClassHandle)
458 // std::string parameterName;
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) {
467 // return parameterName;
470 RTI13ObjectInstance* getObjectInstance(const std::string& name)
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.");
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)); }
486 // RTIHandle getRoutingSpaceHandle(const std::string& routingSpaceName)
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) {
495 // return RTIHandle(-1);
497 // std::string getRoutingSpaceName(const RTIHandle& routingSpaceHandle)
499 // std::string routingSpaceName;
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) {
507 // return routingSpaceName;
510 void enableClassRelevanceAdvisorySwitch()
511 { _rtiAmbassador.enableClassRelevanceAdvisorySwitch(); }
512 void disableClassRelevanceAdvisorySwitch()
513 { _rtiAmbassador.disableClassRelevanceAdvisorySwitch(); }
515 void enableAttributeRelevanceAdvisorySwitch()
516 { _rtiAmbassador.enableAttributeRelevanceAdvisorySwitch(); }
517 void disableAttributeRelevanceAdvisorySwitch()
518 { _rtiAmbassador.disableAttributeRelevanceAdvisorySwitch(); }
520 void enableAttributeScopeAdvisorySwitch()
521 { _rtiAmbassador.enableAttributeScopeAdvisorySwitch(); }
522 void disableAttributeScopeAdvisorySwitch()
523 { _rtiAmbassador.disableAttributeScopeAdvisorySwitch(); }
525 void enableInteractionRelevanceAdvisorySwitch()
526 { _rtiAmbassador.enableInteractionRelevanceAdvisorySwitch(); }
527 void disableInteractionRelevanceAdvisorySwitch()
528 { _rtiAmbassador.disableInteractionRelevanceAdvisorySwitch(); }
532 { return _rtiAmbassador.tick(); }
533 bool tick(double minimum, double maximum)
534 { return _rtiAmbassador.tick(minimum, maximum); }
536 void addObjectInstanceForCallback(RTIObjectInstance* objectIntance)
537 { _objectInstancePendingCallbackList.insert(objectIntance); }
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 {
544 virtual ~QueueCallback() {}
545 virtual void operator()() = 0;
548 class RemoveObjectCallback : public QueueCallback {
550 RemoveObjectCallback(SGSharedPtr<RTIObjectInstance> objectInstance, const RTIData& tag) :
551 _objectInstance(objectInstance),
554 virtual void operator()()
556 _objectInstance->removeInstance(_tag);
559 SGSharedPtr<RTIObjectInstance> _objectInstance;
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)
569 virtual ~FederateAmbassador()
570 throw (RTI::FederateInternalError)
574 /// RTI federate ambassador callback functions.
575 virtual void synchronizationPointRegistrationSucceeded(const char* label)
576 throw (RTI::FederateInternalError)
580 virtual void synchronizationPointRegistrationFailed(const char* label)
581 throw (RTI::FederateInternalError)
585 virtual void announceSynchronizationPoint(const char* label, const char* tag)
586 throw (RTI::FederateInternalError)
588 _rtiAmbassador._pendingSyncLabels.insert(toStdString(label));
591 virtual void federationSynchronized(const char* label)
592 throw (RTI::FederateInternalError)
594 std::string s = toStdString(label);
595 _rtiAmbassador._pendingSyncLabels.erase(s);
596 _rtiAmbassador._syncronizedSyncLabels.insert(s);
599 virtual void initiateFederateSave(const char* label)
600 throw (RTI::UnableToPerformSave,
601 RTI::FederateInternalError)
605 virtual void federationSaved()
606 throw (RTI::FederateInternalError)
610 virtual void federationNotSaved()
611 throw (RTI::FederateInternalError)
615 virtual void requestFederationRestoreSucceeded(const char* label)
616 throw (RTI::FederateInternalError)
620 virtual void requestFederationRestoreFailed(const char* label, const char* reason)
621 throw (RTI::FederateInternalError)
625 virtual void federationRestoreBegun()
626 throw (RTI::FederateInternalError)
630 virtual void initiateFederateRestore(const char* label, RTI::FederateHandle federateHandle)
631 throw (RTI::SpecifiedSaveLabelDoesNotExist,
632 RTI::CouldNotRestore,
633 RTI::FederateInternalError)
637 virtual void federationRestored()
638 throw (RTI::FederateInternalError)
642 virtual void federationNotRestored()
643 throw (RTI::FederateInternalError)
647 // Declaration Management
648 virtual void startRegistrationForObjectClass(RTI::ObjectClassHandle objectClassHandle)
649 throw (RTI::ObjectClassNotPublished,
650 RTI::FederateInternalError)
652 ObjectClassMap::iterator i = _rtiAmbassador._objectClassMap.find(objectClassHandle);
653 if (i == _rtiAmbassador._objectClassMap.end())
655 if (!i->second.valid())
657 i->second->startRegistration();
660 virtual void stopRegistrationForObjectClass(RTI::ObjectClassHandle objectClassHandle)
661 throw (RTI::ObjectClassNotPublished,
662 RTI::FederateInternalError)
664 ObjectClassMap::iterator i = _rtiAmbassador._objectClassMap.find(objectClassHandle);
665 if (i == _rtiAmbassador._objectClassMap.end())
667 if (!i->second.valid())
669 i->second->stopRegistration();
672 virtual void turnInteractionsOn(RTI::InteractionClassHandle interactionClassHandle)
673 throw (RTI::InteractionClassNotPublished,
674 RTI::FederateInternalError)
678 virtual void turnInteractionsOff(RTI::InteractionClassHandle interactionClassHandle)
679 throw (RTI::InteractionClassNotPublished,
680 RTI::FederateInternalError)
686 virtual void discoverObjectInstance(RTI::ObjectHandle objectHandle, RTI::ObjectClassHandle objectClassHandle, const char* tag)
687 throw (RTI::CouldNotDiscover,
688 RTI::ObjectClassNotKnown,
689 RTI::FederateInternalError)
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())
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));
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)
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())
715 i->second->reflectAttributeValues(attributeValuePairSet, toTimeStamp(fedTime), tagToData(tag));
718 virtual void reflectAttributeValues(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleValuePairSet& attributeValuePairSet,
720 throw (RTI::ObjectNotKnown,
721 RTI::AttributeNotKnown,
722 RTI::FederateOwnsAttributes,
723 RTI::FederateInternalError)
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())
730 i->second->reflectAttributeValues(attributeValuePairSet, tagToData(tag));
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)
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)
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)
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);
765 virtual void removeObjectInstance(RTI::ObjectHandle objectHandle, const char* tag)
766 throw (RTI::ObjectNotKnown,
767 RTI::FederateInternalError)
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);
778 virtual void attributesInScope(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
779 throw (RTI::ObjectNotKnown,
780 RTI::AttributeNotKnown,
781 RTI::FederateInternalError)
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())
788 i->second->attributesInScope(attributes);
791 virtual void attributesOutOfScope(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
792 throw (RTI::ObjectNotKnown,
793 RTI::AttributeNotKnown,
794 RTI::FederateInternalError)
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())
801 i->second->attributesOutOfScope(attributes);
804 virtual void provideAttributeValueUpdate(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
805 throw (RTI::ObjectNotKnown,
806 RTI::AttributeNotKnown,
807 RTI::AttributeNotOwned,
808 RTI::FederateInternalError)
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())
815 i->second->provideAttributeValueUpdate(attributes);
818 virtual void turnUpdatesOnForObjectInstance(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
819 throw (RTI::ObjectNotKnown,
820 RTI::AttributeNotOwned,
821 RTI::FederateInternalError)
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())
828 i->second->turnUpdatesOnForObjectInstance(attributes);
831 virtual void turnUpdatesOffForObjectInstance(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
832 throw (RTI::ObjectNotKnown,
833 RTI::AttributeNotOwned,
834 RTI::FederateInternalError)
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())
841 i->second->turnUpdatesOffForObjectInstance(attributes);
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)
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())
858 i->second->requestAttributeOwnershipAssumption(attributes, tagToData(tag));
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)
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())
873 i->second->attributeOwnershipDivestitureNotification(attributes);
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)
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())
889 i->second->attributeOwnershipAcquisitionNotification(attributes);
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)
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())
904 i->second->attributeOwnershipUnavailable(attributes);
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)
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())
919 i->second->requestAttributeOwnershipRelease(attributes, tagToData(tag));
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)
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())
934 i->second->confirmAttributeOwnershipAcquisitionCancellation(attributes);
937 virtual void informAttributeOwnership(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle,
938 RTI::FederateHandle federateHandle)
939 throw (RTI::ObjectNotKnown,
940 RTI::AttributeNotKnown,
941 RTI::FederateInternalError)
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())
948 i->second->informAttributeOwnership(attributeHandle, federateHandle);
951 virtual void attributeIsNotOwned(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle)
952 throw (RTI::ObjectNotKnown,
953 RTI::AttributeNotKnown,
954 RTI::FederateInternalError)
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())
961 i->second->attributeIsNotOwned(attributeHandle);
964 virtual void attributeOwnedByRTI(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle)
965 throw (RTI::ObjectNotKnown,
966 RTI::AttributeNotKnown,
967 RTI::FederateInternalError)
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())
974 i->second->attributeOwnedByRTI(attributeHandle);
978 virtual void timeRegulationEnabled(const RTI::FedTime& fedTime)
979 throw (RTI::InvalidFederationTime,
980 RTI::EnableTimeRegulationWasNotPending,
981 RTI::FederateInternalError)
983 _rtiAmbassador._timeRegulationEnabled = true;
984 _rtiAmbassador._federateTime = toTimeStamp(fedTime);
985 SG_LOG(SG_NETWORK, SG_INFO, "RTI: timeRegulationEnabled: " << _rtiAmbassador._federateTime);
988 virtual void timeConstrainedEnabled(const RTI::FedTime& fedTime)
989 throw (RTI::InvalidFederationTime,
990 RTI::EnableTimeConstrainedWasNotPending,
991 RTI::FederateInternalError)
993 _rtiAmbassador._timeConstrainedEnabled = true;
994 _rtiAmbassador._federateTime = toTimeStamp(fedTime);
995 SG_LOG(SG_NETWORK, SG_INFO, "RTI: timeConstrainedEnabled: " << _rtiAmbassador._federateTime);
998 virtual void timeAdvanceGrant(const RTI::FedTime& fedTime)
999 throw (RTI::InvalidFederationTime,
1000 RTI::TimeAdvanceWasNotInProgress,
1001 RTI::FederateInternalError)
1003 _rtiAmbassador._federateTime = toTimeStamp(fedTime);
1004 _rtiAmbassador._timeAdvancePending = false;
1005 SG_LOG(SG_NETWORK, SG_INFO, "RTI: timeAdvanceGrant: " << _rtiAmbassador._federateTime);
1008 virtual void requestRetraction(RTI::EventRetractionHandle eventRetractionHandle)
1009 throw (RTI::EventNotKnown,
1010 RTI::FederateInternalError)
1012 // No retraction concept yet
1016 const RTIData& tagToData(const char* tag)
1019 _cachedTag.setData(tag, std::strlen(tag) + 1);
1021 _cachedTag.setData("", 1);
1026 RTI13Ambassador& _rtiAmbassador;
1029 static SGTimeStamp toTimeStamp(const RTI::FedTime& fedTime)
1031 RTIfedTime referenceTime(fedTime);
1032 return SGTimeStamp::fromSec(referenceTime.getTime() + 0.5e-9);
1035 static RTIfedTime toFedTime(const SGTimeStamp& timeStamp)
1037 RTIfedTime referenceTime;
1038 referenceTime.setZero();
1039 referenceTime += timeStamp.toSecs();
1040 return referenceTime;
1043 static std::string rtiToStdString(char* n)
1046 return std::string();
1053 static std::string toStdString(const char* n)
1056 return std::string();
1057 return std::string(n);
1060 // The connection class
1061 RTI::RTIambassador _rtiAmbassador;
1063 // The class with all the callbacks.
1064 FederateAmbassador _federateAmbassador;
1066 // All the sync labels we got an announcement for
1067 std::set<std::string> _pendingSyncLabels;
1068 std::set<std::string> _syncronizedSyncLabels;
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;
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;
1084 // Top level information for dispatching creation of federate objects
1085 typedef std::map<RTI::ObjectClassHandle, SGSharedPtr<RTI13ObjectClass> > ObjectClassMap;
1086 ObjectClassMap _objectClassMap;
1088 bool _timeRegulationEnabled;
1089 bool _timeConstrainedEnabled;
1090 bool _timeAdvancePending;
1091 SGTimeStamp _federateTime;
1094 } // namespace simgear