1 // Copyright (C) 2009 - 2011 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 #include "RTI13Federate.hxx"
20 #include "RTI13Ambassador.hxx"
24 static std::string toStdString(const char* n)
28 return std::string(n);
31 /// Just the interface class doing the callbacks into the parent class
32 struct RTI13Federate::FederateAmbassador : public RTI::FederateAmbassador {
33 FederateAmbassador() :
34 _timeRegulationEnabled(false),
35 _timeConstrainedEnabled(false),
36 _timeAdvancePending(false)
39 virtual ~FederateAmbassador()
40 throw (RTI::FederateInternalError)
44 /// Generic callback to execute some notification on objects in a way that they are not prone to
45 /// ConcurrentAccess exceptions.
46 class QueueCallback : public SGReferenced {
48 virtual ~QueueCallback() {}
49 virtual void operator()(FederateAmbassador& self) = 0;
51 class TagQueueCallback : public QueueCallback {
53 TagQueueCallback(const char* tag)
56 _tag.setData(tag, std::strlen(tag) + 1);
60 virtual ~TagQueueCallback()
65 /// RTI federate ambassador callback functions.
66 virtual void synchronizationPointRegistrationSucceeded(const char* label)
67 throw (RTI::FederateInternalError)
71 virtual void synchronizationPointRegistrationFailed(const char* label)
72 throw (RTI::FederateInternalError)
76 virtual void announceSynchronizationPoint(const char* label, const char* tag)
77 throw (RTI::FederateInternalError)
79 _pendingSyncLabels.insert(toStdString(label));
82 virtual void federationSynchronized(const char* label)
83 throw (RTI::FederateInternalError)
85 std::string s = toStdString(label);
86 _pendingSyncLabels.erase(s);
87 _syncronizedSyncLabels.insert(s);
90 virtual void initiateFederateSave(const char* label)
91 throw (RTI::UnableToPerformSave,
92 RTI::FederateInternalError)
96 virtual void federationSaved()
97 throw (RTI::FederateInternalError)
101 virtual void federationNotSaved()
102 throw (RTI::FederateInternalError)
106 virtual void requestFederationRestoreSucceeded(const char* label)
107 throw (RTI::FederateInternalError)
111 virtual void requestFederationRestoreFailed(const char* label, const char* reason)
112 throw (RTI::FederateInternalError)
116 virtual void federationRestoreBegun()
117 throw (RTI::FederateInternalError)
121 virtual void initiateFederateRestore(const char* label, RTI::FederateHandle federateHandle)
122 throw (RTI::SpecifiedSaveLabelDoesNotExist,
123 RTI::CouldNotRestore,
124 RTI::FederateInternalError)
128 virtual void federationRestored()
129 throw (RTI::FederateInternalError)
133 virtual void federationNotRestored()
134 throw (RTI::FederateInternalError)
138 // Declaration Management
139 class StartRegistrationForObjectClassCallback : public QueueCallback {
141 StartRegistrationForObjectClassCallback(RTI::ObjectClassHandle objectClassHandle) :
142 _objectClassHandle(objectClassHandle)
144 virtual void operator()(FederateAmbassador& self)
145 { self.startRegistrationForObjectClassCallback(_objectClassHandle); }
147 RTI::ObjectClassHandle _objectClassHandle;
149 virtual void startRegistrationForObjectClass(RTI::ObjectClassHandle objectClassHandle)
150 throw (RTI::ObjectClassNotPublished,
151 RTI::FederateInternalError)
152 { _queueCallbackList.push_back(new StartRegistrationForObjectClassCallback(objectClassHandle)); }
153 void startRegistrationForObjectClassCallback(RTI::ObjectClassHandle objectClassHandle)
155 ObjectClassMap::iterator i = _objectClassMap.find(objectClassHandle);
156 if (i == _objectClassMap.end())
158 if (!i->second.valid())
160 i->second->startRegistration();
163 class StopRegistrationForObjectClassCallback : public QueueCallback {
165 StopRegistrationForObjectClassCallback(RTI::ObjectClassHandle objectClassHandle) :
166 _objectClassHandle(objectClassHandle)
168 virtual void operator()(FederateAmbassador& self)
169 { self.stopRegistrationForObjectClassCallback(_objectClassHandle); }
171 RTI::ObjectClassHandle _objectClassHandle;
173 virtual void stopRegistrationForObjectClass(RTI::ObjectClassHandle objectClassHandle)
174 throw (RTI::ObjectClassNotPublished,
175 RTI::FederateInternalError)
176 { _queueCallbackList.push_back(new StopRegistrationForObjectClassCallback(objectClassHandle)); }
177 void stopRegistrationForObjectClassCallback(RTI::ObjectClassHandle objectClassHandle)
179 ObjectClassMap::iterator i = _objectClassMap.find(objectClassHandle);
180 if (i == _objectClassMap.end())
182 if (!i->second.valid())
184 i->second->stopRegistration();
187 virtual void turnInteractionsOn(RTI::InteractionClassHandle interactionClassHandle)
188 throw (RTI::InteractionClassNotPublished,
189 RTI::FederateInternalError)
193 virtual void turnInteractionsOff(RTI::InteractionClassHandle interactionClassHandle)
194 throw (RTI::InteractionClassNotPublished,
195 RTI::FederateInternalError)
200 class DiscoverObjectCallback : public TagQueueCallback {
202 DiscoverObjectCallback(RTI::ObjectHandle objectHandle, RTI::ObjectClassHandle objectClassHandle, const char *tag) :
203 TagQueueCallback(tag),
204 _objectHandle(objectHandle),
205 _objectClassHandle(objectClassHandle)
207 virtual void operator()(FederateAmbassador& self)
208 { self.discoverObjectInstanceCallback(_objectHandle, _objectClassHandle, _tag); }
210 RTI::ObjectHandle _objectHandle;
211 RTI::ObjectClassHandle _objectClassHandle;
213 virtual void discoverObjectInstance(RTI::ObjectHandle objectHandle, RTI::ObjectClassHandle objectClassHandle, const char* tag)
214 throw (RTI::CouldNotDiscover,
215 RTI::ObjectClassNotKnown,
216 RTI::FederateInternalError)
217 { _queueCallbackList.push_back(new DiscoverObjectCallback(objectHandle, objectClassHandle, tag)); }
218 void discoverObjectInstanceCallback(RTI::ObjectHandle objectHandle, RTI::ObjectClassHandle objectClassHandle, const RTIData& tag)
220 ObjectClassMap::iterator i = _objectClassMap.find(objectClassHandle);
221 if (i == _objectClassMap.end())
223 if (!i->second.valid())
225 SGSharedPtr<RTI13ObjectInstance> objectInstance = new RTI13ObjectInstance(objectHandle, 0, i->second, _rtiAmbassador.get(), false);
226 _objectInstanceMap[objectHandle] = objectInstance;
227 i->second->discoverInstance(objectInstance.get(), tag);
230 class ReflectAttributeValuesTimestampCallback : public TagQueueCallback {
232 ReflectAttributeValuesTimestampCallback(RTI::ObjectHandle objectHandle,
233 RTI13AttributeHandleDataPairList& attributeHandleDataPairList,
234 const SGTimeStamp& timeStamp, const char *tag) :
235 TagQueueCallback(tag),
236 _objectHandle(objectHandle),
237 _timeStamp(timeStamp)
239 _attributeHandleDataPairList.swap(attributeHandleDataPairList);
241 virtual void operator()(FederateAmbassador& self)
243 self.reflectAttributeValuesCallback(_objectHandle, _attributeHandleDataPairList, _timeStamp, _tag);
244 self.freeAttributeHandleDataPairList(_attributeHandleDataPairList);
247 RTI::ObjectHandle _objectHandle;
248 RTI13AttributeHandleDataPairList _attributeHandleDataPairList;
249 SGTimeStamp _timeStamp;
251 virtual void reflectAttributeValues(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleValuePairSet& attributeValuePairSet,
252 const RTI::FedTime& fedTime, const char* tag, RTI::EventRetractionHandle eventRetractionHandle)
253 throw (RTI::ObjectNotKnown,
254 RTI::AttributeNotKnown,
255 RTI::FederateOwnsAttributes,
256 RTI::InvalidFederationTime,
257 RTI::FederateInternalError)
259 RTI13AttributeHandleDataPairList attributeHandleDataPairList;
261 RTI::ULong numAttribs = attributeValuePairSet.size();
262 for (RTI::ULong i = 0; i < numAttribs; ++i) {
263 appendAttributeHandleDataPair(attributeHandleDataPairList);
264 attributeHandleDataPairList.back().first = attributeValuePairSet.getHandle(i);
265 RTI::ULong length = attributeValuePairSet.getValueLength(i);
266 attributeHandleDataPairList.back().second.resize(length);
267 attributeValuePairSet.getValue(i, attributeHandleDataPairList.back().second.data(), length);
270 _queueCallbackList.push_back(new ReflectAttributeValuesTimestampCallback(objectHandle, attributeHandleDataPairList,
271 RTI13Ambassador::toTimeStamp(fedTime), tag));
273 void reflectAttributeValuesCallback(RTI::ObjectHandle objectHandle, RTI13AttributeHandleDataPairList& attributeHandleDataPairList,
274 const SGTimeStamp& timeStamp, const RTIData& tag)
276 ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
277 if (i == _objectInstanceMap.end())
279 if (!i->second.valid())
281 i->second->reflectAttributeValues(attributeHandleDataPairList, timeStamp, tag);
284 class ReflectAttributeValuesCallback : public TagQueueCallback {
286 ReflectAttributeValuesCallback(RTI::ObjectHandle objectHandle, RTI13AttributeHandleDataPairList& attributeHandleDataPairList,
288 TagQueueCallback(tag),
289 _objectHandle(objectHandle)
291 _attributeHandleDataPairList.swap(attributeHandleDataPairList);
293 virtual void operator()(FederateAmbassador& self)
295 self.reflectAttributeValuesCallback(_objectHandle, _attributeHandleDataPairList, _tag);
296 self.freeAttributeHandleDataPairList(_attributeHandleDataPairList);
299 RTI::ObjectHandle _objectHandle;
300 RTI13AttributeHandleDataPairList _attributeHandleDataPairList;
302 virtual void reflectAttributeValues(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleValuePairSet& attributeValuePairSet,
304 throw (RTI::ObjectNotKnown,
305 RTI::AttributeNotKnown,
306 RTI::FederateOwnsAttributes,
307 RTI::FederateInternalError)
309 RTI13AttributeHandleDataPairList attributeHandleDataPairList;
311 RTI::ULong numAttribs = attributeValuePairSet.size();
312 for (RTI::ULong i = 0; i < numAttribs; ++i) {
313 appendAttributeHandleDataPair(attributeHandleDataPairList);
314 attributeHandleDataPairList.back().first = attributeValuePairSet.getHandle(i);
315 RTI::ULong length = attributeValuePairSet.getValueLength(i);
316 attributeHandleDataPairList.back().second.resize(length);
317 attributeValuePairSet.getValue(i, attributeHandleDataPairList.back().second.data(), length);
320 _queueCallbackList.push_back(new ReflectAttributeValuesCallback(objectHandle, attributeHandleDataPairList, tag));
322 void reflectAttributeValuesCallback(RTI::ObjectHandle objectHandle, RTI13AttributeHandleDataPairList& attributeHandleDataPairList,
325 ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
326 if (i == _objectInstanceMap.end())
328 if (!i->second.valid())
330 i->second->reflectAttributeValues(attributeHandleDataPairList, tag);
333 virtual void receiveInteraction(RTI::InteractionClassHandle interactionClassHandle, const RTI::ParameterHandleValuePairSet& parameters,
334 const RTI::FedTime& fedTime, const char* tag, RTI::EventRetractionHandle eventRetractionHandle)
335 throw (RTI::InteractionClassNotKnown,
336 RTI::InteractionParameterNotKnown,
337 RTI::InvalidFederationTime,
338 RTI::FederateInternalError)
342 virtual void receiveInteraction(RTI::InteractionClassHandle interactionClassHandle,
343 const RTI::ParameterHandleValuePairSet& parameters, const char* tag)
344 throw (RTI::InteractionClassNotKnown,
345 RTI::InteractionParameterNotKnown,
346 RTI::FederateInternalError)
350 class RemoveObjectTimestampCallback : public TagQueueCallback {
352 RemoveObjectTimestampCallback(RTI::ObjectHandle objectHandle, const SGTimeStamp& timeStamp, const char* tag) :
353 TagQueueCallback(tag),
354 _objectHandle(objectHandle),
355 _timeStamp(timeStamp)
357 virtual void operator()(FederateAmbassador& self)
358 { self.removeObjectInstanceCallback(_objectHandle, _timeStamp, _tag); }
360 RTI::ObjectHandle _objectHandle;
361 SGTimeStamp _timeStamp;
363 virtual void removeObjectInstance(RTI::ObjectHandle objectHandle, const RTI::FedTime& fedTime,
364 const char* tag, RTI::EventRetractionHandle eventRetractionHandle)
365 throw (RTI::ObjectNotKnown,
366 RTI::InvalidFederationTime,
367 RTI::FederateInternalError)
368 { _queueCallbackList.push_back(new RemoveObjectTimestampCallback(objectHandle, RTI13Ambassador::toTimeStamp(fedTime), tag)); }
369 void removeObjectInstanceCallback(RTI::ObjectHandle objectHandle, const SGTimeStamp& timeStamp, const RTIData& tag)
371 ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
372 if (i == _objectInstanceMap.end())
374 if (i->second.valid())
375 i->second->removeInstance(tag);
376 _objectInstanceMap.erase(i);
379 class RemoveObjectCallback : public TagQueueCallback {
381 RemoveObjectCallback(RTI::ObjectHandle objectHandle, const char* tag) :
382 TagQueueCallback(tag),
383 _objectHandle(objectHandle)
385 virtual void operator()(FederateAmbassador& self)
386 { self.removeObjectInstanceCallback(_objectHandle, _tag); }
388 RTI::ObjectHandle _objectHandle;
390 virtual void removeObjectInstance(RTI::ObjectHandle objectHandle, const char* tag)
391 throw (RTI::ObjectNotKnown,
392 RTI::FederateInternalError)
393 { _queueCallbackList.push_back(new RemoveObjectCallback(objectHandle, tag)); }
394 void removeObjectInstanceCallback(RTI::ObjectHandle objectHandle, const RTIData& tag)
396 ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
397 if (i == _objectInstanceMap.end())
399 if (i->second.valid())
400 i->second->removeInstance(tag);
401 _objectInstanceMap.erase(i);
404 class AttributeHandleSetCallback : public QueueCallback {
406 AttributeHandleSetCallback(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributeHandleSet) :
407 _objectHandle(objectHandle)
409 RTI::ULong numAttribs = attributeHandleSet.size();
410 _attributes.reserve(numAttribs);
411 for (RTI::ULong i = 0; i < numAttribs; ++i)
412 _attributes.push_back(attributeHandleSet.getHandle(i));
415 RTI::ObjectHandle _objectHandle;
416 std::vector<RTI::AttributeHandle> _attributes;
418 class AttributesInScopeCallback : public AttributeHandleSetCallback {
420 AttributesInScopeCallback(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes) :
421 AttributeHandleSetCallback(objectHandle, attributes)
423 virtual void operator()(FederateAmbassador& self)
424 { self.attributesInScopeCallback(_objectHandle, _attributes); }
426 virtual void attributesInScope(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
427 throw (RTI::ObjectNotKnown,
428 RTI::AttributeNotKnown,
429 RTI::FederateInternalError)
430 { _queueCallbackList.push_back(new AttributesInScopeCallback(objectHandle, attributes)); }
431 void attributesInScopeCallback(RTI::ObjectHandle objectHandle, const std::vector<RTI::AttributeHandle>& attributes)
433 ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
434 if (i == _objectInstanceMap.end())
436 if (!i->second.valid())
438 i->second->attributesInScope(attributes);
441 class AttributesOutOfScopeCallback : public AttributeHandleSetCallback {
443 AttributesOutOfScopeCallback(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes) :
444 AttributeHandleSetCallback(objectHandle, attributes)
446 virtual void operator()(FederateAmbassador& self)
447 { self.attributesOutOfScopeCallback(_objectHandle, _attributes); }
449 virtual void attributesOutOfScope(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
450 throw (RTI::ObjectNotKnown,
451 RTI::AttributeNotKnown,
452 RTI::FederateInternalError)
453 { _queueCallbackList.push_back(new AttributesOutOfScopeCallback(objectHandle, attributes)); }
454 void attributesOutOfScopeCallback(RTI::ObjectHandle objectHandle, const std::vector<RTI::AttributeHandle>& attributes)
456 ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
457 if (i == _objectInstanceMap.end())
459 if (!i->second.valid())
461 i->second->attributesOutOfScope(attributes);
464 class ProvideAttributeValueUpdateCallback : public AttributeHandleSetCallback {
466 ProvideAttributeValueUpdateCallback(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes) :
467 AttributeHandleSetCallback(objectHandle, attributes)
469 virtual void operator()(FederateAmbassador& self)
470 { self.provideAttributeValueUpdateCallback(_objectHandle, _attributes); }
472 virtual void provideAttributeValueUpdate(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
473 throw (RTI::ObjectNotKnown,
474 RTI::AttributeNotKnown,
475 RTI::AttributeNotOwned,
476 RTI::FederateInternalError)
477 { _queueCallbackList.push_back(new ProvideAttributeValueUpdateCallback(objectHandle, attributes)); }
478 void provideAttributeValueUpdateCallback(RTI::ObjectHandle objectHandle, const std::vector<RTI::AttributeHandle>& attributes)
480 ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
481 if (i == _objectInstanceMap.end())
483 if (!i->second.valid())
485 i->second->provideAttributeValueUpdate(attributes);
488 class TurnUpdatesOnForObjectInstanceCallback : public AttributeHandleSetCallback {
490 TurnUpdatesOnForObjectInstanceCallback(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes) :
491 AttributeHandleSetCallback(objectHandle, attributes)
493 virtual void operator()(FederateAmbassador& self)
494 { self.turnUpdatesOnForObjectInstanceCallback(_objectHandle, _attributes); }
496 virtual void turnUpdatesOnForObjectInstance(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
497 throw (RTI::ObjectNotKnown,
498 RTI::AttributeNotOwned,
499 RTI::FederateInternalError)
500 { _queueCallbackList.push_back(new TurnUpdatesOnForObjectInstanceCallback(objectHandle, attributes)); }
501 void turnUpdatesOnForObjectInstanceCallback(RTI::ObjectHandle objectHandle, const std::vector<RTI::AttributeHandle>& attributes)
503 ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
504 if (i == _objectInstanceMap.end())
506 if (!i->second.valid())
508 i->second->turnUpdatesOnForObjectInstance(attributes);
511 class TurnUpdatesOffForObjectInstanceCallback : public AttributeHandleSetCallback {
513 TurnUpdatesOffForObjectInstanceCallback(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes) :
514 AttributeHandleSetCallback(objectHandle, attributes)
516 virtual void operator()(FederateAmbassador& self)
517 { self.turnUpdatesOffForObjectInstanceCallback(_objectHandle, _attributes); }
519 virtual void turnUpdatesOffForObjectInstance(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
520 throw (RTI::ObjectNotKnown,
521 RTI::AttributeNotOwned,
522 RTI::FederateInternalError)
523 { _queueCallbackList.push_back(new TurnUpdatesOffForObjectInstanceCallback(objectHandle, attributes)); }
524 void turnUpdatesOffForObjectInstanceCallback(RTI::ObjectHandle objectHandle, const std::vector<RTI::AttributeHandle>& attributes)
526 ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
527 if (i == _objectInstanceMap.end())
529 if (!i->second.valid())
531 i->second->turnUpdatesOffForObjectInstance(attributes);
534 // Ownership Management
535 class RequestAttributeOwnershipAssumptionCallback : public AttributeHandleSetCallback {
537 RequestAttributeOwnershipAssumptionCallback(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes, const RTIData& tag) :
538 AttributeHandleSetCallback(objectHandle, attributes),
541 virtual void operator()(FederateAmbassador& self)
542 { self.requestAttributeOwnershipAssumptionCallback(_objectHandle, _attributes, _tag); }
546 virtual void requestAttributeOwnershipAssumption(RTI::ObjectHandle objectHandle,
547 const RTI::AttributeHandleSet& attributes, const char* tag)
548 throw (RTI::ObjectNotKnown,
549 RTI::AttributeNotKnown,
550 RTI::AttributeAlreadyOwned,
551 RTI::AttributeNotPublished,
552 RTI::FederateInternalError)
553 { _queueCallbackList.push_back(new RequestAttributeOwnershipAssumptionCallback(objectHandle, attributes, tagToData(tag))); }
554 void requestAttributeOwnershipAssumptionCallback(RTI::ObjectHandle objectHandle, std::vector<RTI::AttributeHandle>& attributes, const RTIData& tag)
556 ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
557 if (i == _objectInstanceMap.end())
559 if (!i->second.valid())
561 i->second->requestAttributeOwnershipAssumption(attributes, tag);
564 class AttributeOwnershipDivestitureNotificationCallback : public AttributeHandleSetCallback {
566 AttributeOwnershipDivestitureNotificationCallback(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes) :
567 AttributeHandleSetCallback(objectHandle, attributes)
569 virtual void operator()(FederateAmbassador& self)
570 { self.attributeOwnershipDivestitureNotificationCallback(_objectHandle, _attributes); }
572 virtual void attributeOwnershipDivestitureNotification(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
573 throw (RTI::ObjectNotKnown,
574 RTI::AttributeNotKnown,
575 RTI::AttributeNotOwned,
576 RTI::AttributeDivestitureWasNotRequested,
577 RTI::FederateInternalError)
578 { _queueCallbackList.push_back(new AttributeOwnershipDivestitureNotificationCallback(objectHandle, attributes)); }
579 void attributeOwnershipDivestitureNotificationCallback(RTI::ObjectHandle objectHandle, const std::vector<RTI::AttributeHandle>& attributes)
581 ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
582 if (i == _objectInstanceMap.end())
584 if (!i->second.valid())
586 i->second->attributeOwnershipDivestitureNotification(attributes);
589 class AttributeOwnershipAcquisitionNotificationCallback : public AttributeHandleSetCallback {
591 AttributeOwnershipAcquisitionNotificationCallback(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes) :
592 AttributeHandleSetCallback(objectHandle, attributes)
594 virtual void operator()(FederateAmbassador& self)
595 { self.attributeOwnershipAcquisitionNotificationCallback(_objectHandle, _attributes); }
597 virtual void attributeOwnershipAcquisitionNotification(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
598 throw (RTI::ObjectNotKnown,
599 RTI::AttributeNotKnown,
600 RTI::AttributeAcquisitionWasNotRequested,
601 RTI::AttributeAlreadyOwned,
602 RTI::AttributeNotPublished,
603 RTI::FederateInternalError)
604 { _queueCallbackList.push_back(new AttributeOwnershipAcquisitionNotificationCallback(objectHandle, attributes)); }
605 void attributeOwnershipAcquisitionNotificationCallback(RTI::ObjectHandle objectHandle, const std::vector<RTI::AttributeHandle>& attributes)
607 ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
608 if (i == _objectInstanceMap.end())
610 if (!i->second.valid())
612 i->second->attributeOwnershipAcquisitionNotification(attributes);
615 class AttributeOwnershipUnavailableCallback : public AttributeHandleSetCallback {
617 AttributeOwnershipUnavailableCallback(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes) :
618 AttributeHandleSetCallback(objectHandle, attributes)
620 virtual void operator()(FederateAmbassador& self)
621 { self.attributeOwnershipUnavailableCallback(_objectHandle, _attributes); }
623 virtual void attributeOwnershipUnavailable(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
624 throw (RTI::ObjectNotKnown,
625 RTI::AttributeNotKnown,
626 RTI::AttributeAlreadyOwned,
627 RTI::AttributeAcquisitionWasNotRequested,
628 RTI::FederateInternalError)
629 { _queueCallbackList.push_back(new AttributeOwnershipUnavailableCallback(objectHandle, attributes)); }
630 void attributeOwnershipUnavailableCallback(RTI::ObjectHandle objectHandle, const std::vector<RTI::AttributeHandle>& attributes)
632 ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
633 if (i == _objectInstanceMap.end())
635 if (!i->second.valid())
637 i->second->attributeOwnershipUnavailable(attributes);
640 class RequestAttributeOwnershipReleaseCallback : public AttributeHandleSetCallback {
642 RequestAttributeOwnershipReleaseCallback(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes, const RTIData& tag) :
643 AttributeHandleSetCallback(objectHandle, attributes),
646 virtual void operator()(FederateAmbassador& self)
647 { self.requestAttributeOwnershipReleaseCallback(_objectHandle, _attributes, _tag); }
651 virtual void requestAttributeOwnershipRelease(RTI::ObjectHandle objectHandle,
652 const RTI::AttributeHandleSet& attributes, const char* tag)
653 throw (RTI::ObjectNotKnown,
654 RTI::AttributeNotKnown,
655 RTI::AttributeNotOwned,
656 RTI::FederateInternalError)
657 { _queueCallbackList.push_back(new RequestAttributeOwnershipReleaseCallback(objectHandle, attributes, tagToData(tag))); }
658 void requestAttributeOwnershipReleaseCallback(RTI::ObjectHandle objectHandle, std::vector<RTI::AttributeHandle>& attributes, const RTIData& tag)
660 ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
661 if (i == _objectInstanceMap.end())
663 if (!i->second.valid())
665 i->second->requestAttributeOwnershipRelease(attributes, tag);
668 class ConfirmAttributeOwnershipAcquisitionCancellationCallback : public AttributeHandleSetCallback {
670 ConfirmAttributeOwnershipAcquisitionCancellationCallback(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes) :
671 AttributeHandleSetCallback(objectHandle, attributes)
673 virtual void operator()(FederateAmbassador& self)
674 { self.confirmAttributeOwnershipAcquisitionCancellationCallback(_objectHandle, _attributes); }
676 virtual void confirmAttributeOwnershipAcquisitionCancellation(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
677 throw (RTI::ObjectNotKnown,
678 RTI::AttributeNotKnown,
679 RTI::AttributeAlreadyOwned,
680 RTI::AttributeAcquisitionWasNotCanceled,
681 RTI::FederateInternalError)
682 { _queueCallbackList.push_back(new ConfirmAttributeOwnershipAcquisitionCancellationCallback(objectHandle, attributes)); }
683 void confirmAttributeOwnershipAcquisitionCancellationCallback(RTI::ObjectHandle objectHandle, const std::vector<RTI::AttributeHandle>& attributes)
685 ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
686 if (i == _objectInstanceMap.end())
688 if (!i->second.valid())
690 i->second->confirmAttributeOwnershipAcquisitionCancellation(attributes);
693 class InformAttributeOwnershipCallback : public QueueCallback {
695 InformAttributeOwnershipCallback(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle, RTI::FederateHandle federateHandle) :
696 _objectHandle(objectHandle),
697 _attributeHandle(attributeHandle),
698 _federateHandle(federateHandle)
700 virtual void operator()(FederateAmbassador& self)
701 { self.informAttributeOwnershipCallback(_objectHandle, _attributeHandle, _federateHandle); }
703 RTI::ObjectHandle _objectHandle;
704 RTI::AttributeHandle _attributeHandle;
705 RTI::FederateHandle _federateHandle;
707 virtual void informAttributeOwnership(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle,
708 RTI::FederateHandle federateHandle)
709 throw (RTI::ObjectNotKnown,
710 RTI::AttributeNotKnown,
711 RTI::FederateInternalError)
712 { _queueCallbackList.push_back(new InformAttributeOwnershipCallback(objectHandle, attributeHandle, federateHandle)); }
713 void informAttributeOwnershipCallback(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle, RTI::FederateHandle federateHandle)
715 ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
716 if (i == _objectInstanceMap.end())
718 if (!i->second.valid())
720 i->second->informAttributeOwnership(attributeHandle, federateHandle);
723 class AttributeIsNotOwnedCallback : public QueueCallback {
725 AttributeIsNotOwnedCallback(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle) :
726 _objectHandle(objectHandle),
727 _attributeHandle(attributeHandle)
729 virtual void operator()(FederateAmbassador& self)
730 { self.attributeIsNotOwnedCallback(_objectHandle, _attributeHandle); }
732 RTI::ObjectHandle _objectHandle;
733 RTI::AttributeHandle _attributeHandle;
735 virtual void attributeIsNotOwned(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle)
736 throw (RTI::ObjectNotKnown,
737 RTI::AttributeNotKnown,
738 RTI::FederateInternalError)
739 { _queueCallbackList.push_back(new AttributeIsNotOwnedCallback(objectHandle, attributeHandle)); }
740 void attributeIsNotOwnedCallback(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle)
742 ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
743 if (i == _objectInstanceMap.end())
745 if (!i->second.valid())
747 i->second->attributeIsNotOwned(attributeHandle);
750 class AttributeOwnedByRTICallback : public QueueCallback {
752 AttributeOwnedByRTICallback(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle) :
753 _objectHandle(objectHandle),
754 _attributeHandle(attributeHandle)
756 virtual void operator()(FederateAmbassador& self)
757 { self.attributeOwnedByRTICallback(_objectHandle, _attributeHandle); }
759 RTI::ObjectHandle _objectHandle;
760 RTI::AttributeHandle _attributeHandle;
762 virtual void attributeOwnedByRTI(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle)
763 throw (RTI::ObjectNotKnown,
764 RTI::AttributeNotKnown,
765 RTI::FederateInternalError)
766 { _queueCallbackList.push_back(new AttributeOwnedByRTICallback(objectHandle, attributeHandle)); }
767 void attributeOwnedByRTICallback(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle)
769 ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
770 if (i == _objectInstanceMap.end())
772 if (!i->second.valid())
774 i->second->attributeOwnedByRTI(attributeHandle);
778 virtual void timeRegulationEnabled(const RTI::FedTime& fedTime)
779 throw (RTI::InvalidFederationTime,
780 RTI::EnableTimeRegulationWasNotPending,
781 RTI::FederateInternalError)
783 _timeRegulationEnabled = true;
784 SG_LOG(SG_NETWORK, SG_INFO, "RTI: timeRegulationEnabled: " << RTI13Ambassador::toTimeStamp(fedTime));
787 virtual void timeConstrainedEnabled(const RTI::FedTime& fedTime)
788 throw (RTI::InvalidFederationTime,
789 RTI::EnableTimeConstrainedWasNotPending,
790 RTI::FederateInternalError)
792 _timeConstrainedEnabled = true;
793 SG_LOG(SG_NETWORK, SG_INFO, "RTI: timeConstrainedEnabled: " << RTI13Ambassador::toTimeStamp(fedTime));
796 virtual void timeAdvanceGrant(const RTI::FedTime& fedTime)
797 throw (RTI::InvalidFederationTime,
798 RTI::TimeAdvanceWasNotInProgress,
799 RTI::FederateInternalError)
801 _timeAdvancePending = false;
802 // SG_LOG(SG_NETWORK, SG_INFO, "RTI: timeAdvanceGrant: " << RTI13Ambassador::toTimeStamp(fedTime));
805 virtual void requestRetraction(RTI::EventRetractionHandle eventRetractionHandle)
806 throw (RTI::EventNotKnown,
807 RTI::FederateInternalError)
809 // No retraction concept yet
812 // processes the queues that filled up during the past
815 while (!_queueCallbackList.empty()) {
816 (*_queueCallbackList.front())(*this);
817 // _queueCallbackListPool.splice();
818 _queueCallbackList.pop_front();
822 bool getFederationSynchronizationPointAnnounced(const std::string& label)
823 { return _pendingSyncLabels.find(label) != _pendingSyncLabels.end(); }
824 bool getFederationSynchronized(const std::string& label)
826 std::set<std::string>::iterator i = _syncronizedSyncLabels.find(label);
827 if (i == _syncronizedSyncLabels.end())
829 _syncronizedSyncLabels.erase(i);
833 // The rtiambassador to issue requests
834 SGSharedPtr<RTI13Ambassador> _rtiAmbassador;
836 // All the sync labels we got an announcement for
837 std::set<std::string> _pendingSyncLabels;
838 std::set<std::string> _syncronizedSyncLabels;
840 // All that calls back into user code is just queued.
841 // That is to make sure we do not call recursively into the RTI
842 typedef std::list<SGSharedPtr<QueueCallback> > QueueCallbackList;
843 QueueCallbackList _queueCallbackList;
844 // QueueCallbackList _queueCallbackListPool;
846 RTI13AttributeHandleDataPairList _attributeHandleDataPairPool;
847 void appendAttributeHandleDataPair(RTI13AttributeHandleDataPairList& attributeHandleDataPairList)
849 if (_attributeHandleDataPairPool.empty())
850 attributeHandleDataPairList.push_back(RTI13AttributeHandleDataPair());
852 attributeHandleDataPairList.splice(attributeHandleDataPairList.end(),
853 _attributeHandleDataPairPool, _attributeHandleDataPairPool.begin());
855 void freeAttributeHandleDataPairList(RTI13AttributeHandleDataPairList& attributeHandleDataPairList)
856 { _attributeHandleDataPairPool.splice(_attributeHandleDataPairPool.end(), attributeHandleDataPairList); }
858 // Top level information for dispatching federate object attribute updates
859 typedef std::map<RTI::ObjectHandle, SGSharedPtr<RTI13ObjectInstance> > ObjectInstanceMap;
860 // Map of all available objects
861 ObjectInstanceMap _objectInstanceMap;
863 // Top level information for dispatching creation of federate objects
864 typedef std::map<RTI::ObjectClassHandle, SGSharedPtr<RTI13ObjectClass> > ObjectClassMap;
865 ObjectClassMap _objectClassMap;
867 bool _timeRegulationEnabled;
868 bool _timeConstrainedEnabled;
869 bool _timeAdvancePending;
872 const RTIData& tagToData(const char* tag)
875 _cachedTag.setData(tag, std::strlen(tag) + 1);
877 _cachedTag.setData("", 1);
883 RTI13Federate::RTI13Federate(const std::list<std::string>& stringList) :
885 _ambassador(new RTI13Ambassador),
886 _federateAmbassador(new FederateAmbassador)
888 _ambassador->_federate = this;
889 _federateAmbassador->_rtiAmbassador = _ambassador;
890 if (stringList.empty()) {
891 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Ignoring non empty connect arguments while connecting to an RTI13 federation!");
895 RTI13Federate::~RTI13Federate()
898 _ambassador->resignFederationExecution();
899 delete _federateAmbassador;
902 RTI13Federate::FederationManagementResult
903 RTI13Federate::createFederationExecution(const std::string& federationName, const std::string& objectModel)
906 _ambassador->createFederationExecution(federationName, objectModel);
907 return FederationManagementSuccess;
908 } catch (RTI::FederationExecutionAlreadyExists& e) {
909 return FederationManagementFail;
910 } catch (RTI::CouldNotOpenFED& e) {
911 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not create federation execution: " << e._name << " " << e._reason);
912 return FederationManagementFatal;
913 } catch (RTI::ErrorReadingFED& e) {
914 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not create federation execution: " << e._name << " " << e._reason);
915 return FederationManagementFatal;
916 } catch (RTI::ConcurrentAccessAttempted& e) {
917 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not create federation execution: " << e._name << " " << e._reason);
918 return FederationManagementFatal;
919 } catch (RTI::RTIinternalError& e) {
920 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not create federation execution: " << e._name << " " << e._reason);
921 return FederationManagementFatal;
925 RTI13Federate::FederationManagementResult
926 RTI13Federate::destroyFederationExecution(const std::string& federation)
929 _ambassador->destroyFederationExecution(federation);
930 return FederationManagementSuccess;
931 } catch (RTI::FederatesCurrentlyJoined& e) {
932 return FederationManagementFail;
933 } catch (RTI::FederationExecutionDoesNotExist& e) {
934 return FederationManagementFail;
935 } catch (RTI::ConcurrentAccessAttempted& e) {
936 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not destroy federation execution: " << e._name << " " << e._reason);
937 return FederationManagementFatal;
938 } catch (RTI::RTIinternalError& e) {
939 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not destroy federation execution: " << e._name << " " << e._reason);
940 return FederationManagementFatal;
944 RTI13Federate::FederationManagementResult
945 RTI13Federate::join(const std::string& federateType, const std::string& federationName)
948 _federateHandle = _ambassador->joinFederationExecution(federateType, federationName, _federateAmbassador);
949 SG_LOG(SG_NETWORK, SG_INFO, "RTI: Joined federation \""
950 << federationName << "\" as \"" << federateType << "\"");
952 return FederationManagementSuccess;
953 } catch (RTI::FederateAlreadyExecutionMember& e) {
954 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason);
955 return FederationManagementFatal;
956 } catch (RTI::FederationExecutionDoesNotExist& e) {
957 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason);
958 return FederationManagementFail;
959 } catch (RTI::CouldNotOpenFED& e) {
960 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason);
961 return FederationManagementFatal;
962 } catch (RTI::ErrorReadingFED& e) {
963 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason);
964 return FederationManagementFatal;
965 } catch (RTI::ConcurrentAccessAttempted& e) {
966 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason);
967 return FederationManagementFatal;
968 } catch (RTI::SaveInProgress& e) {
969 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason);
970 return FederationManagementFatal;
971 } catch (RTI::RestoreInProgress& e) {
972 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason);
973 return FederationManagementFatal;
974 } catch (RTI::RTIinternalError& e) {
975 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason);
976 return FederationManagementFatal;
981 RTI13Federate::resign()
984 _ambassador->resignFederationExecution();
985 SG_LOG(SG_NETWORK, SG_INFO, "RTI: Resigned from federation.");
987 _federateHandle = -1;
989 } catch (RTI::FederateOwnsAttributes& e) {
990 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
992 } catch (RTI::FederateNotExecutionMember& e) {
993 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
995 } catch (RTI::InvalidResignAction& e) {
996 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
998 } catch (RTI::ConcurrentAccessAttempted& e) {
999 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1001 } catch (RTI::RTIinternalError& e) {
1002 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1008 RTI13Federate::getJoined() const
1014 RTI13Federate::registerFederationSynchronizationPoint(const std::string& label, const RTIData& tag)
1017 _ambassador->registerFederationSynchronizationPoint(label, tag);
1018 SG_LOG(SG_NETWORK, SG_INFO, "RTI: registerFederationSynchronizationPoint(" << label << ", tag )");
1020 } catch (RTI::FederateNotExecutionMember& e) {
1021 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not register federation synchronization point: " << e._name << " " << e._reason);
1023 } catch (RTI::ConcurrentAccessAttempted& e) {
1024 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not register federation synchronization point: " << e._name << " " << e._reason);
1026 } catch (RTI::SaveInProgress& e) {
1027 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not register federation synchronization point: " << e._name << " " << e._reason);
1029 } catch (RTI::RestoreInProgress& e) {
1030 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not register federation synchronization point: " << e._name << " " << e._reason);
1032 } catch (RTI::RTIinternalError& e) {
1033 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not register federation synchronization point: " << e._name << " " << e._reason);
1039 RTI13Federate::getFederationSynchronizationPointAnnounced(const std::string& label)
1041 return _federateAmbassador->getFederationSynchronizationPointAnnounced(label);
1045 RTI13Federate::synchronizationPointAchieved(const std::string& label)
1048 _ambassador->synchronizationPointAchieved(label);
1049 SG_LOG(SG_NETWORK, SG_INFO, "RTI: synchronizationPointAchieved(" << label << ")");
1051 } catch (RTI::SynchronizationPointLabelWasNotAnnounced& e) {
1052 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not signal synchronization point: " << e._name << " " << e._reason);
1054 } catch (RTI::FederateNotExecutionMember& e) {
1055 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not signal synchronization point: " << e._name << " " << e._reason);
1057 } catch (RTI::ConcurrentAccessAttempted& e) {
1058 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not signal synchronization point: " << e._name << " " << e._reason);
1060 } catch (RTI::SaveInProgress& e) {
1061 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not signal synchronization point: " << e._name << " " << e._reason);
1063 } catch (RTI::RestoreInProgress& e) {
1064 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not signal synchronization point: " << e._name << " " << e._reason);
1066 } catch (RTI::RTIinternalError& e) {
1067 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not signal synchronization point: " << e._name << " " << e._reason);
1073 RTI13Federate::getFederationSynchronized(const std::string& label)
1075 return _federateAmbassador->getFederationSynchronized(label);
1079 RTI13Federate::enableTimeConstrained()
1081 if (!_ambassador.valid()) {
1082 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time constrained at unconnected federate.");
1086 if (_federateAmbassador->_timeConstrainedEnabled) {
1087 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Time constrained is already enabled.");
1092 _ambassador->enableTimeConstrained();
1093 } catch (RTI::TimeConstrainedAlreadyEnabled& e) {
1094 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time constrained: " << e._name << " " << e._reason);
1096 } catch (RTI::EnableTimeConstrainedPending& e) {
1097 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time constrained: " << e._name << " " << e._reason);
1099 } catch (RTI::TimeAdvanceAlreadyInProgress& e) {
1100 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time constrained: " << e._name << " " << e._reason);
1102 } catch (RTI::ConcurrentAccessAttempted& e) {
1103 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time constrained: " << e._name << " " << e._reason);
1105 } catch (RTI::FederateNotExecutionMember& e) {
1106 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time constrained: " << e._name << " " << e._reason);
1108 } catch (RTI::SaveInProgress& e) {
1109 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time constrained: " << e._name << " " << e._reason);
1111 } catch (RTI::RestoreInProgress& e) {
1112 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time constrained: " << e._name << " " << e._reason);
1114 } catch (RTI::RTIinternalError& e) {
1115 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time constrained: " << e._name << " " << e._reason);
1123 RTI13Federate::disableTimeConstrained()
1125 if (!_ambassador.valid()) {
1126 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time constrained at unconnected federate.");
1130 if (!_federateAmbassador->_timeConstrainedEnabled) {
1131 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Time constrained is not enabled.");
1136 _ambassador->disableTimeConstrained();
1137 _federateAmbassador->_timeConstrainedEnabled = false;
1138 } catch (RTI::TimeConstrainedWasNotEnabled& e) {
1139 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time constrained: " << e._name << " " << e._reason);
1141 } catch (RTI::FederateNotExecutionMember& e) {
1142 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time constrained: " << e._name << " " << e._reason);
1144 } catch (RTI::ConcurrentAccessAttempted& e) {
1145 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time constrained: " << e._name << " " << e._reason);
1147 } catch (RTI::SaveInProgress& e) {
1148 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time constrained: " << e._name << " " << e._reason);
1150 } catch (RTI::RestoreInProgress& e) {
1151 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time constrained: " << e._name << " " << e._reason);
1153 } catch (RTI::RTIinternalError& e) {
1154 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time constrained: " << e._name << " " << e._reason);
1162 RTI13Federate::getTimeConstrainedEnabled()
1164 return _federateAmbassador->_timeConstrainedEnabled;
1168 RTI13Federate::enableTimeRegulation(const SGTimeStamp& lookahead)
1170 if (!_ambassador.valid()) {
1171 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time regulation at unconnected federate.");
1175 if (_federateAmbassador->_timeRegulationEnabled) {
1176 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Time regulation already enabled.");
1181 _ambassador->enableTimeRegulation(lookahead);
1182 } catch (RTI::TimeRegulationAlreadyEnabled& e) {
1183 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time regulation: " << e._name << " " << e._reason);
1185 } catch (RTI::EnableTimeRegulationPending& e) {
1186 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time regulation: " << e._name << " " << e._reason);
1188 } catch (RTI::TimeAdvanceAlreadyInProgress& e) {
1189 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time regulation: " << e._name << " " << e._reason);
1191 } catch (RTI::InvalidFederationTime& e) {
1192 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time regulation: " << e._name << " " << e._reason);
1194 } catch (RTI::InvalidLookahead& e) {
1195 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time regulation: " << e._name << " " << e._reason);
1197 } catch (RTI::ConcurrentAccessAttempted& e) {
1198 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time regulation: " << e._name << " " << e._reason);
1200 } catch (RTI::FederateNotExecutionMember& e) {
1201 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time regulation: " << e._name << " " << e._reason);
1203 } catch (RTI::SaveInProgress& e) {
1204 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time regulation: " << e._name << " " << e._reason);
1206 } catch (RTI::RestoreInProgress& e) {
1207 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time regulation: " << e._name << " " << e._reason);
1209 } catch (RTI::RTIinternalError& e) {
1210 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time regulation: " << e._name << " " << e._reason);
1218 RTI13Federate::disableTimeRegulation()
1220 if (!_ambassador.valid()) {
1221 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time regulation at unconnected federate.");
1225 if (!_federateAmbassador->_timeRegulationEnabled) {
1226 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Time regulation is not enabled.");
1231 _ambassador->disableTimeRegulation();
1232 _federateAmbassador->_timeRegulationEnabled = false;
1233 } catch (RTI::TimeRegulationWasNotEnabled& e) {
1234 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time regulation: " << e._name << " " << e._reason);
1236 } catch (RTI::ConcurrentAccessAttempted& e) {
1237 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time regulation: " << e._name << " " << e._reason);
1239 } catch (RTI::FederateNotExecutionMember& e) {
1240 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time regulation: " << e._name << " " << e._reason);
1242 } catch (RTI::SaveInProgress& e) {
1243 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time regulation: " << e._name << " " << e._reason);
1245 } catch (RTI::RestoreInProgress& e) {
1246 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time regulation: " << e._name << " " << e._reason);
1248 } catch (RTI::RTIinternalError& e) {
1249 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time regulation: " << e._name << " " << e._reason);
1257 RTI13Federate::modifyLookahead(const SGTimeStamp& timeStamp)
1259 if (!_ambassador.valid()) {
1260 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not modify lookahead.");
1264 _ambassador->modifyLookahead(timeStamp);
1265 } catch (RTI::InvalidLookahead& e) {
1266 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not modify lookahead: " << e._name << " " << e._reason);
1268 } catch (RTI::FederateNotExecutionMember& e) {
1269 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not modify lookahead: " << e._name << " " << e._reason);
1271 } catch (RTI::ConcurrentAccessAttempted& e) {
1272 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not modify lookahead: " << e._name << " " << e._reason);
1274 } catch (RTI::SaveInProgress& e) {
1275 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not modify lookahead: " << e._name << " " << e._reason);
1277 } catch (RTI::RestoreInProgress& e) {
1278 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not modify lookahead: " << e._name << " " << e._reason);
1280 } catch (RTI::RTIinternalError& e) {
1281 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not modify lookahead: " << e._name << " " << e._reason);
1288 RTI13Federate::getTimeRegulationEnabled()
1290 return _federateAmbassador->_timeRegulationEnabled;
1294 RTI13Federate::timeAdvanceRequest(const SGTimeStamp& timeStamp)
1296 if (!_ambassador.valid()) {
1297 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time at unconnected federate.");
1302 _ambassador->timeAdvanceRequest(timeStamp);
1303 _federateAmbassador->_timeAdvancePending = true;
1304 } catch (RTI::InvalidFederationTime& e) {
1305 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1307 } catch (RTI::FederationTimeAlreadyPassed& e) {
1308 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1310 } catch (RTI::TimeAdvanceAlreadyInProgress& e) {
1311 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1313 } catch (RTI::EnableTimeRegulationPending& e) {
1314 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1316 } catch (RTI::EnableTimeConstrainedPending& e) {
1317 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1319 } catch (RTI::FederateNotExecutionMember& e) {
1320 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1322 } catch (RTI::ConcurrentAccessAttempted& e) {
1323 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1325 } catch (RTI::SaveInProgress& e) {
1326 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1328 } catch (RTI::RestoreInProgress& e) {
1329 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1331 } catch (RTI::RTIinternalError& e) {
1332 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1340 RTI13Federate::timeAdvanceRequestAvailable(const SGTimeStamp& timeStamp)
1342 if (!_ambassador.valid()) {
1343 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time at unconnected federate.");
1348 _ambassador->timeAdvanceRequestAvailable(timeStamp);
1349 _federateAmbassador->_timeAdvancePending = true;
1350 } catch (RTI::InvalidFederationTime& e) {
1351 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1353 } catch (RTI::FederationTimeAlreadyPassed& e) {
1354 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1356 } catch (RTI::TimeAdvanceAlreadyInProgress& e) {
1357 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1359 } catch (RTI::EnableTimeRegulationPending& e) {
1360 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1362 } catch (RTI::EnableTimeConstrainedPending& e) {
1363 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1365 } catch (RTI::FederateNotExecutionMember& e) {
1366 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1368 } catch (RTI::ConcurrentAccessAttempted& e) {
1369 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1371 } catch (RTI::SaveInProgress& e) {
1372 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1374 } catch (RTI::RestoreInProgress& e) {
1375 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1377 } catch (RTI::RTIinternalError& e) {
1378 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1386 RTI13Federate::flushQueueRequest(const SGTimeStamp& timeStamp)
1388 if (!_ambassador.valid()) {
1389 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not flush queue at unconnected federate.");
1394 _ambassador->flushQueueRequest(timeStamp);
1395 _federateAmbassador->_timeAdvancePending = true;
1396 } catch (RTI::InvalidFederationTime& e) {
1397 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not flush queue: " << e._name << " " << e._reason);
1399 } catch (RTI::FederationTimeAlreadyPassed& e) {
1400 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not flush queue: " << e._name << " " << e._reason);
1402 } catch (RTI::TimeAdvanceAlreadyInProgress& e) {
1403 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not flush queue: " << e._name << " " << e._reason);
1405 } catch (RTI::EnableTimeRegulationPending& e) {
1406 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not flush queue: " << e._name << " " << e._reason);
1408 } catch (RTI::EnableTimeConstrainedPending& e) {
1409 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not flush queue: " << e._name << " " << e._reason);
1411 } catch (RTI::FederateNotExecutionMember& e) {
1412 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not flush queue: " << e._name << " " << e._reason);
1414 } catch (RTI::ConcurrentAccessAttempted& e) {
1415 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not flush queue: " << e._name << " " << e._reason);
1417 } catch (RTI::SaveInProgress& e) {
1418 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not flush queue: " << e._name << " " << e._reason);
1420 } catch (RTI::RestoreInProgress& e) {
1421 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not flush queue: " << e._name << " " << e._reason);
1423 } catch (RTI::RTIinternalError& e) {
1424 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not flush queue: " << e._name << " " << e._reason);
1432 RTI13Federate::getTimeAdvancePending()
1434 return _federateAmbassador->_timeAdvancePending;
1438 RTI13Federate::queryFederateTime(SGTimeStamp& timeStamp)
1440 if (!_ambassador.valid()) {
1441 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query federate time.");
1446 _ambassador->queryFederateTime(timeStamp);
1447 } catch (RTI::FederateNotExecutionMember& e) {
1448 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query federate time: " << e._name << " " << e._reason);
1450 } catch (RTI::ConcurrentAccessAttempted& e) {
1451 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query federate time: " << e._name << " " << e._reason);
1453 } catch (RTI::SaveInProgress& e) {
1454 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query federate time: " << e._name << " " << e._reason);
1456 } catch (RTI::RestoreInProgress& e) {
1457 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query federate time: " << e._name << " " << e._reason);
1459 } catch (RTI::RTIinternalError& e) {
1460 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query federate time: " << e._name << " " << e._reason);
1467 RTI13Federate::queryLookahead(SGTimeStamp& timeStamp)
1469 if (!_ambassador.valid()) {
1470 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query lookahead.");
1475 _ambassador->queryLookahead(timeStamp);
1476 } catch (RTI::FederateNotExecutionMember& e) {
1477 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query lookahead: " << e._name << " " << e._reason);
1479 } catch (RTI::ConcurrentAccessAttempted& e) {
1480 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query lookahead: " << e._name << " " << e._reason);
1482 } catch (RTI::SaveInProgress& e) {
1483 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query lookahead: " << e._name << " " << e._reason);
1485 } catch (RTI::RestoreInProgress& e) {
1486 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query lookahead: " << e._name << " " << e._reason);
1488 } catch (RTI::RTIinternalError& e) {
1489 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query lookahead: " << e._name << " " << e._reason);
1496 RTI13Federate::queryGALT(SGTimeStamp& timeStamp)
1498 if (!_ambassador.valid()) {
1499 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query GALT.");
1504 return _ambassador->queryGALT(timeStamp);
1505 } catch (RTI::FederateNotExecutionMember& e) {
1506 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query GALT: " << e._name << " " << e._reason);
1508 } catch (RTI::ConcurrentAccessAttempted& e) {
1509 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query GALT: " << e._name << " " << e._reason);
1511 } catch (RTI::SaveInProgress& e) {
1512 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query GALT: " << e._name << " " << e._reason);
1514 } catch (RTI::RestoreInProgress& e) {
1515 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query GALT: " << e._name << " " << e._reason);
1517 } catch (RTI::RTIinternalError& e) {
1518 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query GALT: " << e._name << " " << e._reason);
1525 RTI13Federate::queryLITS(SGTimeStamp& timeStamp)
1527 if (!_ambassador.valid()) {
1528 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query LITS.");
1533 return _ambassador->queryLITS(timeStamp);
1534 } catch (RTI::FederateNotExecutionMember& e) {
1535 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query LITS: " << e._name << " " << e._reason);
1537 } catch (RTI::ConcurrentAccessAttempted& e) {
1538 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query LITS: " << e._name << " " << e._reason);
1540 } catch (RTI::SaveInProgress& e) {
1541 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query LITS: " << e._name << " " << e._reason);
1543 } catch (RTI::RestoreInProgress& e) {
1544 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query LITS: " << e._name << " " << e._reason);
1546 } catch (RTI::RTIinternalError& e) {
1547 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query LITS: " << e._name << " " << e._reason);
1554 RTI13Federate::processMessage()
1556 bool result = _ambassador->tick();
1557 _federateAmbassador->processQueues();
1562 RTI13Federate::processMessages(const double& minimum, const double& maximum)
1564 bool result = _ambassador->tick(minimum, 0);
1565 _federateAmbassador->processQueues();
1568 SGTimeStamp timeStamp = SGTimeStamp::now() + SGTimeStamp::fromSec(maximum);
1570 result = _ambassador->tick(0, 0);
1571 _federateAmbassador->processQueues();
1572 } while (result && SGTimeStamp::now() <= timeStamp);
1577 RTI13Federate::createObjectClass(const std::string& objectClassName, HLAObjectClass* hlaObjectClass)
1580 RTI::ObjectClassHandle objectClassHandle;
1581 objectClassHandle = _ambassador->getObjectClassHandle(objectClassName);
1582 if (_federateAmbassador->_objectClassMap.find(objectClassHandle) != _federateAmbassador->_objectClassMap.end()) {
1583 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not create object class, object class already exists!");
1586 RTI13ObjectClass* rtiObjectClass;
1587 rtiObjectClass = new RTI13ObjectClass(hlaObjectClass, objectClassHandle, _ambassador.get());
1588 _federateAmbassador->_objectClassMap[objectClassHandle] = rtiObjectClass;
1589 return rtiObjectClass;
1590 } catch (RTI::NameNotFound& e) {
1591 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: " << e._name << " " << e._reason);
1593 } catch (RTI::FederateNotExecutionMember& e) {
1594 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: " << e._name << " " << e._reason);
1596 } catch (RTI::ConcurrentAccessAttempted& e) {
1597 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: " << e._name << " " << e._reason);
1599 } catch (RTI::RTIinternalError& e) {
1600 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: " << e._name << " " << e._reason);
1605 RTI13ObjectInstance*
1606 RTI13Federate::getObjectInstance(const std::string& objectInstanceName)
1609 RTI::ObjectHandle objectHandle;
1610 objectHandle = _ambassador->getObjectInstanceHandle(objectInstanceName);
1611 FederateAmbassador::ObjectInstanceMap::iterator i = _federateAmbassador->_objectInstanceMap.find(objectHandle);
1612 if (i == _federateAmbassador->_objectInstanceMap.end()) {
1613 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object instance: ObjectInstance not found.");
1617 } catch (RTI::ObjectNotKnown& e) {
1618 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object instance: " << e._name << " " << e._reason);
1620 } catch (RTI::FederateNotExecutionMember& e) {
1621 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object instance: " << e._name << " " << e._reason);
1623 } catch (RTI::ConcurrentAccessAttempted& e) {
1624 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object instance: " << e._name << " " << e._reason);
1626 } catch (RTI::RTIinternalError& e) {
1627 SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object instance: " << e._name << " " << e._reason);
1633 RTI13Federate::insertObjectInstance(RTI13ObjectInstance* objectInstance)
1635 _federateAmbassador->_objectInstanceMap[objectInstance->getHandle()] = objectInstance;