1 // Copyright (C) 2009 - 2012 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.
19 # include <simgear_config.h>
22 #include <simgear/compiler.h>
24 #include "HLAFederate.hxx"
28 #include "simgear/debug/logstream.hxx"
30 #include "RTIFederate.hxx"
31 #include "RTIFederateFactoryRegistry.hxx"
32 #include "RTI13FederateFactory.hxx"
33 #include "RTIInteractionClass.hxx"
34 #include "RTIObjectClass.hxx"
35 #include "HLADataElement.hxx"
36 #include "HLADataType.hxx"
37 #include "HLAOMTXmlVisitor.hxx"
41 HLAFederate::HLAFederate() :
43 _createFederationExecution(true),
44 _timeConstrained(false),
45 _timeRegulating(false),
46 _timeConstrainedByLocalClock(false),
49 // For now instantiate the current only available factory here explicitly
50 RTI13FederateFactory::instance();
53 HLAFederate::~HLAFederate()
57 // Remove the data type references from the data types.
58 // This is to remove the cycles from the data types that might happen if a data type references itself
59 for (DataTypeMap::iterator i = _dataTypeMap.begin(); i != _dataTypeMap.end(); ++i) {
60 i->second->releaseDataTypeReferences();
65 HLAFederate::getVersion() const
71 HLAFederate::setVersion(HLAFederate::Version version)
73 if (_rtiFederate.valid()) {
74 SG_LOG(SG_NETWORK, SG_ALERT, "HLA: Ignoring HLAFederate parameter setting on already connected federate!");
82 HLAFederate::setVersion(const std::string& version)
84 if (version == "RTI13")
85 return setVersion(RTI13);
86 else if (version == "RTI1516")
87 return setVersion(RTI1516);
88 else if (version == "RTI1516E")
89 return setVersion(RTI1516E);
91 /// at some time think about routing these down to the factory
92 SG_LOG(SG_NETWORK, SG_ALERT, "HLA: Unknown version string in HLAFederate::setVersion!");
97 const std::list<std::string>&
98 HLAFederate::getConnectArguments() const
100 return _connectArguments;
104 HLAFederate::setConnectArguments(const std::list<std::string>& connectArguments)
106 if (_rtiFederate.valid()) {
107 SG_LOG(SG_NETWORK, SG_ALERT, "HLA: Ignoring HLAFederate parameter setting on already connected federate!");
110 _connectArguments = connectArguments;
115 HLAFederate::getCreateFederationExecution() const
117 return _createFederationExecution;
121 HLAFederate::setCreateFederationExecution(bool createFederationExecution)
123 _createFederationExecution = createFederationExecution;
128 HLAFederate::getFederationExecutionName() const
130 return _federationExecutionName;
134 HLAFederate::setFederationExecutionName(const std::string& federationExecutionName)
136 if (_rtiFederate.valid()) {
137 SG_LOG(SG_NETWORK, SG_ALERT, "HLA: Ignoring HLAFederate parameter setting on already connected federate!");
140 _federationExecutionName = federationExecutionName;
145 HLAFederate::getFederationObjectModel() const
147 return _federationObjectModel;
151 HLAFederate::setFederationObjectModel(const std::string& federationObjectModel)
153 if (_rtiFederate.valid()) {
154 SG_LOG(SG_NETWORK, SG_ALERT, "HLA: Ignoring HLAFederate parameter setting on already connected federate!");
157 _federationObjectModel = federationObjectModel;
162 HLAFederate::getFederateType() const
164 return _federateType;
168 HLAFederate::setFederateType(const std::string& federateType)
170 if (_rtiFederate.valid()) {
171 SG_LOG(SG_NETWORK, SG_ALERT, "HLA: Ignoring HLAFederate parameter setting on already connected federate!");
174 _federateType = federateType;
179 HLAFederate::getFederateName() const
181 return _federateName;
185 HLAFederate::setFederateName(const std::string& federateName)
187 if (_rtiFederate.valid()) {
188 SG_LOG(SG_NETWORK, SG_ALERT, "HLA: Ignoring HLAFederate parameter setting on already connected federate!");
191 _federateName = federateName;
196 HLAFederate::connect(Version version, const std::list<std::string>& stringList)
199 _connectArguments = stringList;
204 HLAFederate::connect()
206 if (_rtiFederate.valid()) {
207 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Trying to connect to already connected federate!");
211 SGSharedPtr<RTIFederateFactoryRegistry> registry = RTIFederateFactoryRegistry::instance();
213 SG_LOG(SG_NETWORK, SG_ALERT, "HLA: RTIFederateFactoryRegistry is no longer available!");
219 _rtiFederate = registry->create("RTI13", _connectArguments);
222 _rtiFederate = registry->create("RTI1516", _connectArguments);
225 _rtiFederate = registry->create("RTI1516E", _connectArguments);
228 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Unknown rti version in connect!");
230 return _rtiFederate.valid();
234 HLAFederate::disconnect()
236 if (!_rtiFederate.valid()) {
237 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!");
246 HLAFederate::createFederationExecution(const std::string& federation, const std::string& objectModel)
248 if (!_rtiFederate.valid()) {
249 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!");
253 RTIFederate::FederationManagementResult createResult;
254 createResult = _rtiFederate->createFederationExecution(federation, objectModel);
255 if (createResult == RTIFederate::FederationManagementFatal)
258 _federationExecutionName = federation;
259 _federationObjectModel = objectModel;
264 HLAFederate::destroyFederationExecution(const std::string& federation)
266 if (!_rtiFederate.valid()) {
267 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!");
271 RTIFederate::FederationManagementResult destroyResult;
272 destroyResult = _rtiFederate->destroyFederationExecution(federation);
273 if (destroyResult == RTIFederate::FederationManagementFatal)
280 HLAFederate::createFederationExecution()
282 if (!_rtiFederate.valid()) {
283 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!");
287 RTIFederate::FederationManagementResult createResult;
288 createResult = _rtiFederate->createFederationExecution(_federationExecutionName, _federationObjectModel);
289 if (createResult != RTIFederate::FederationManagementSuccess)
296 HLAFederate::destroyFederationExecution()
298 if (!_rtiFederate.valid()) {
299 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!");
303 RTIFederate::FederationManagementResult destroyResult;
304 destroyResult = _rtiFederate->destroyFederationExecution(_federationExecutionName);
305 if (destroyResult != RTIFederate::FederationManagementSuccess)
312 HLAFederate::join(const std::string& federateType, const std::string& federation)
314 if (!_rtiFederate.valid()) {
315 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!");
319 RTIFederate::FederationManagementResult joinResult;
320 joinResult = _rtiFederate->join(federateType, federation);
321 if (joinResult == RTIFederate::FederationManagementFatal)
330 if (!_rtiFederate.valid()) {
331 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!");
335 RTIFederate::FederationManagementResult joinResult;
336 joinResult = _rtiFederate->join(_federateType, _federationExecutionName);
337 if (joinResult != RTIFederate::FederationManagementSuccess)
344 HLAFederate::resign()
346 if (!_rtiFederate.valid()) {
347 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!");
350 return _rtiFederate->resign();
354 HLAFederate::createJoinFederationExecution()
356 if (!_rtiFederate.valid()) {
357 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!");
363 RTIFederate::FederationManagementResult joinResult;
364 joinResult = _rtiFederate->join(_federateType, _federationExecutionName);
365 switch (joinResult) {
366 case RTIFederate::FederationManagementSuccess:
367 // Fast return on success
369 case RTIFederate::FederationManagementFatal:
370 // Abort on fatal errors
376 // If not already joinable, try to create the requested federation
377 RTIFederate::FederationManagementResult createResult;
378 createResult = _rtiFederate->createFederationExecution(_federationExecutionName, _federationObjectModel);
379 switch (createResult) {
380 case RTIFederate::FederationManagementFatal:
381 // Abort on fatal errors
391 HLAFederate::resignDestroyFederationExecution()
393 if (!_rtiFederate.valid()) {
394 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!");
399 bool success = _rtiFederate->resign();
401 // and try to destroy, non fatal if still some federates joined
402 if (_rtiFederate->destroyFederationExecution(_federationExecutionName) == RTIFederate::FederationManagementFatal)
409 HLAFederate::getTimeConstrained() const
411 return _timeConstrained;
415 HLAFederate::setTimeConstrained(bool timeConstrained)
417 _timeConstrained = timeConstrained;
419 if (_rtiFederate.valid() && _rtiFederate->getJoined()) {
420 if (_timeConstrained && !_rtiFederate->getTimeConstrainedEnabled()) {
421 if (!enableTimeConstrained())
423 } else if (!_timeConstrained && _rtiFederate->getTimeConstrainedEnabled()) {
424 if (!disableTimeConstrained())
434 HLAFederate::getTimeConstrainedByLocalClock() const
436 return _timeConstrainedByLocalClock;
440 HLAFederate::setTimeConstrainedByLocalClock(bool timeConstrainedByLocalClock)
442 _timeConstrainedByLocalClock = timeConstrainedByLocalClock;
444 if (_rtiFederate.valid() && _rtiFederate->getJoined()) {
445 if (_timeConstrainedByLocalClock) {
446 if (!enableTimeConstrainedByLocalClock())
455 HLAFederate::getTimeRegulating() const
457 return _timeRegulating;
461 HLAFederate::setTimeRegulating(bool timeRegulating)
463 _timeRegulating = timeRegulating;
465 if (_rtiFederate.valid() && _rtiFederate->getJoined()) {
466 if (_timeRegulating && !_rtiFederate->getTimeRegulationEnabled()) {
467 if (!enableTimeRegulation())
469 } else if (!_timeRegulating && _rtiFederate->getTimeRegulationEnabled()) {
470 if (!disableTimeRegulation())
479 HLAFederate::setLeadTime(const SGTimeStamp& leadTime)
481 if (leadTime < SGTimeStamp::fromSec(0)) {
482 SG_LOG(SG_NETWORK, SG_WARN, "Ignoring negative lead time!");
486 _leadTime = leadTime;
488 if (_rtiFederate.valid() && _rtiFederate->getJoined()) {
489 if (!modifyLookahead(_leadTime + SGTimeStamp::fromSec(_timeIncrement.toSecs()*0.9))) {
490 SG_LOG(SG_NETWORK, SG_WARN, "Cannot modify lookahead!");
499 HLAFederate::getLeadTime() const
505 HLAFederate::setTimeIncrement(const SGTimeStamp& timeIncrement)
507 if (timeIncrement < SGTimeStamp::fromSec(0)) {
508 SG_LOG(SG_NETWORK, SG_WARN, "Ignoring negative time increment!");
512 _timeIncrement = timeIncrement;
514 if (_rtiFederate.valid() && _rtiFederate->getJoined()) {
515 if (!modifyLookahead(_leadTime + SGTimeStamp::fromSec(_timeIncrement.toSecs()*0.9))) {
516 SG_LOG(SG_NETWORK, SG_WARN, "Cannot modify lookahead!");
525 HLAFederate::getTimeIncrement() const
527 return _timeIncrement;
531 HLAFederate::enableTimeConstrained()
533 if (!_rtiFederate.valid()) {
534 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!");
538 if (!_rtiFederate->enableTimeConstrained()) {
539 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Could not enable time constrained!");
543 while (!_rtiFederate->getTimeConstrainedEnabled()) {
544 if (RTIFederate::ProcessMessageFatal == _rtiFederate->processMessage()) {
545 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Fatal error on processing messages!");
554 HLAFederate::disableTimeConstrained()
556 if (!_rtiFederate.valid()) {
557 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!");
560 return _rtiFederate->disableTimeConstrained();
564 HLAFederate::enableTimeConstrainedByLocalClock()
566 // Compute the time offset from the system time to the simulation time
567 SGTimeStamp federateTime;
568 if (!queryFederateTime(federateTime)) {
569 SG_LOG(SG_NETWORK, SG_WARN, "Cannot get federate time!");
572 _localClockOffset = SGTimeStamp::now() - federateTime;
577 HLAFederate::enableTimeRegulation(const SGTimeStamp& lookahead)
579 if (!_rtiFederate.valid()) {
580 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!");
584 if (!_rtiFederate->enableTimeRegulation(lookahead)) {
585 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Could not enable time regulation!");
589 while (!_rtiFederate->getTimeRegulationEnabled()) {
590 if (RTIFederate::ProcessMessageFatal == _rtiFederate->processMessage()) {
591 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Fatal error on processing messages!");
600 HLAFederate::enableTimeRegulation()
602 if (!enableTimeRegulation(SGTimeStamp::fromSec(0))) {
603 SG_LOG(SG_NETWORK, SG_WARN, "Cannot enable time regulation!");
606 if (!modifyLookahead(_leadTime + SGTimeStamp::fromSec(_timeIncrement.toSecs()*0.9))) {
607 SG_LOG(SG_NETWORK, SG_WARN, "Cannot modify lookahead!");
614 HLAFederate::disableTimeRegulation()
616 if (!_rtiFederate.valid()) {
617 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!");
620 return _rtiFederate->disableTimeRegulation();
624 HLAFederate::modifyLookahead(const SGTimeStamp& timeStamp)
626 if (!_rtiFederate.valid()) {
627 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!");
630 return _rtiFederate->modifyLookahead(timeStamp);
634 HLAFederate::timeAdvanceBy(const SGTimeStamp& timeIncrement)
636 if (!_rtiFederate.valid()) {
637 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!");
641 SGTimeStamp timeStamp;
642 if (!_rtiFederate->queryFederateTime(timeStamp)) {
643 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Could not query federate time!");
647 if (!_rtiFederate->timeAdvanceRequest(timeStamp + timeIncrement)) {
648 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Time advance request failed!");
652 return processMessages();
656 HLAFederate::timeAdvance(const SGTimeStamp& timeStamp)
658 if (!_rtiFederate.valid()) {
659 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!");
663 if (!_rtiFederate->timeAdvanceRequest(timeStamp)) {
664 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Time advance request failed!");
668 return processMessages();
672 HLAFederate::timeAdvanceAvailable()
674 if (!_rtiFederate.valid()) {
675 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!");
679 SGTimeStamp timeStamp;
680 if (_rtiFederate->queryGALT(timeStamp)) {
681 if (!_rtiFederate->timeAdvanceRequestAvailable(timeStamp)) {
682 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Time advance request failed!");
687 return processMessages();
691 HLAFederate::queryFederateTime(SGTimeStamp& timeStamp)
693 if (!_rtiFederate.valid()) {
694 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!");
697 return _rtiFederate->queryFederateTime(timeStamp);
701 HLAFederate::queryLookahead(SGTimeStamp& timeStamp)
703 if (!_rtiFederate.valid()) {
704 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!");
707 return _rtiFederate->queryLookahead(timeStamp);
711 HLAFederate::processMessage()
713 if (!_rtiFederate.valid()) {
714 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!");
718 if (RTIFederate::ProcessMessageFatal == _rtiFederate->processMessage()) {
719 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Fatal error on processing messages!");
726 HLAFederate::processMessage(const SGTimeStamp& timeout)
728 if (!_rtiFederate.valid()) {
729 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!");
733 if (RTIFederate::ProcessMessageFatal == _rtiFederate->processMessages(timeout.toSecs(), 0)) {
734 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Fatal error on processing messages!");
741 HLAFederate::processMessages()
743 if (!_rtiFederate.valid()) {
744 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!");
748 while (_rtiFederate->getTimeAdvancePending()) {
749 if (RTIFederate::ProcessMessageFatal == _rtiFederate->processMessage()) {
750 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Fatal error on processing messages!");
755 if (_timeConstrainedByLocalClock) {
756 SGTimeStamp federateTime;
757 if (!_rtiFederate->queryFederateTime(federateTime)) {
758 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Error querying federate time!");
761 SGTimeStamp systemTime = federateTime + _localClockOffset;
763 double rest = (systemTime - SGTimeStamp::now()).toSecs();
766 if (RTIFederate::ProcessMessageFatal == _rtiFederate->processMessages(rest, rest)) {
767 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Fatal error on processing messages!");
773 // Now flush just what is left
775 RTIFederate::ProcessMessageResult result = _rtiFederate->processMessages(0, 0);
776 if (RTIFederate::ProcessMessageLast == result)
778 if (RTIFederate::ProcessMessageFatal == result) {
779 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Fatal error on processing messages!");
788 HLAFederate::readRTI13ObjectModelTemplate(const std::string& objectModel)
790 SG_LOG(SG_IO, SG_WARN, "HLA version RTI13 not yet(!?) supported.");
795 HLAFederate::readRTI1516ObjectModelTemplate(const std::string& objectModel)
797 // The XML version of the federate object model.
798 // This one covers the generic attributes, parameters and data types.
799 HLAOMTXmlVisitor omtXmlVisitor;
801 readXML(objectModel, omtXmlVisitor);
802 } catch (const sg_throwable& e) {
803 SG_LOG(SG_IO, SG_ALERT, "Could not open HLA XML object model file: "
807 SG_LOG(SG_IO, SG_ALERT, "Could not open HLA XML object model file");
811 omtXmlVisitor.setToFederate(*this);
813 return resolveObjectModel();
817 HLAFederate::readRTI1516EObjectModelTemplate(const std::string& objectModel)
819 SG_LOG(SG_IO, SG_WARN, "HLA version RTI1516E not yet(!?) supported.");
824 HLAFederate::resolveObjectModel()
826 if (!_rtiFederate.valid()) {
827 SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!");
831 for (InteractionClassMap::iterator i = _interactionClassMap.begin(); i != _interactionClassMap.end(); ++i) {
832 RTIInteractionClass* rtiInteractionClass = _rtiFederate->createInteractionClass(i->second->getName(), i->second.get());
833 if (!rtiInteractionClass) {
834 SG_LOG(SG_NETWORK, SG_ALERT, "HLAFederate::_insertInteractionClass(): "
835 "No RTIInteractionClass found for \"" << i->second->getName() << "\"!");
838 i->second->_setRTIInteractionClass(rtiInteractionClass);
841 for (ObjectClassMap::iterator i = _objectClassMap.begin(); i != _objectClassMap.end(); ++i) {
842 RTIObjectClass* rtiObjectClass = _rtiFederate->createObjectClass(i->second->getName(), i->second.get());
843 if (!rtiObjectClass) {
844 SG_LOG(SG_NETWORK, SG_ALERT, "HLAFederate::_insertObjectClass(): "
845 "No RTIObjectClass found for \"" << i->second->getName() << "\"!");
848 i->second->_setRTIObjectClass(rtiObjectClass);
855 HLAFederate::getDataType(const std::string& name) const
857 DataTypeMap::const_iterator i = _dataTypeMap.find(name);
858 if (i == _dataTypeMap.end())
860 return i->second.get();
864 HLAFederate::insertDataType(const std::string& name, const SGSharedPtr<HLADataType>& dataType)
866 if (!dataType.valid())
868 if (_dataTypeMap.find(name) != _dataTypeMap.end()) {
869 SG_LOG(SG_IO, SG_ALERT, "HLAFederate::insertDataType: data type with name \""
870 << name << "\" already known to federate!");
873 _dataTypeMap.insert(DataTypeMap::value_type(name, dataType));
878 HLAFederate::recomputeDataTypeAlignment()
880 // Finish alignment computations
884 for (DataTypeMap::iterator i = _dataTypeMap.begin(); i != _dataTypeMap.end(); ++i) {
885 if (i->second->recomputeAlignment())
892 HLAFederate::getInteractionClass(const std::string& name)
894 InteractionClassMap::const_iterator i = _interactionClassMap.find(name);
895 if (i == _interactionClassMap.end())
897 return i->second.get();
900 const HLAInteractionClass*
901 HLAFederate::getInteractionClass(const std::string& name) const
903 InteractionClassMap::const_iterator i = _interactionClassMap.find(name);
904 if (i == _interactionClassMap.end())
906 return i->second.get();
910 HLAFederate::createInteractionClass(const std::string& name)
912 return new HLAInteractionClass(name, this);
916 HLAFederate::getObjectClass(const std::string& name)
918 ObjectClassMap::const_iterator i = _objectClassMap.find(name);
919 if (i == _objectClassMap.end())
921 return i->second.get();
924 const HLAObjectClass*
925 HLAFederate::getObjectClass(const std::string& name) const
927 ObjectClassMap::const_iterator i = _objectClassMap.find(name);
928 if (i == _objectClassMap.end())
930 return i->second.get();
934 HLAFederate::createObjectClass(const std::string& name)
936 return new HLAObjectClass(name, this);
940 HLAFederate::getObjectInstance(const std::string& name)
942 ObjectInstanceMap::const_iterator i = _objectInstanceMap.find(name);
943 if (i == _objectInstanceMap.end())
945 return i->second.get();
948 const HLAObjectInstance*
949 HLAFederate::getObjectInstance(const std::string& name) const
951 ObjectInstanceMap::const_iterator i = _objectInstanceMap.find(name);
952 if (i == _objectInstanceMap.end())
954 return i->second.get();
958 HLAFederate::createObjectInstance(HLAObjectClass* objectClass, const std::string& name)
960 return new HLAObjectInstance(objectClass);
964 HLAFederate::setDone(bool done)
970 HLAFederate::getDone() const
976 HLAFederate::readObjectModel()
978 // Depending on the actual version, try to find an apropriate
979 // file format for the given file. The first one is always the
980 // version native object model file format.
981 switch (getVersion()) {
983 if (readRTI13ObjectModelTemplate(getFederationObjectModel()))
985 if (readRTI1516ObjectModelTemplate(getFederationObjectModel()))
987 return readRTI1516EObjectModelTemplate(getFederationObjectModel());
989 if (readRTI1516ObjectModelTemplate(getFederationObjectModel()))
991 if (readRTI1516EObjectModelTemplate(getFederationObjectModel()))
993 return readRTI13ObjectModelTemplate(getFederationObjectModel());
995 if (readRTI1516EObjectModelTemplate(getFederationObjectModel()))
997 if (readRTI1516ObjectModelTemplate(getFederationObjectModel()))
999 return readRTI13ObjectModelTemplate(getFederationObjectModel());
1006 HLAFederate::subscribe()
1008 for (InteractionClassMap::iterator i = _interactionClassMap.begin(); i != _interactionClassMap.end(); ++i) {
1009 if (!i->second->subscribe())
1013 for (ObjectClassMap::iterator i = _objectClassMap.begin(); i != _objectClassMap.end(); ++i) {
1014 if (!i->second->subscribe())
1022 HLAFederate::publish()
1024 for (InteractionClassMap::iterator i = _interactionClassMap.begin(); i != _interactionClassMap.end(); ++i) {
1025 if (!i->second->publish())
1029 for (ObjectClassMap::iterator i = _objectClassMap.begin(); i != _objectClassMap.end(); ++i) {
1030 if (!i->second->publish())
1040 // We need to talk to the rti
1044 if (_createFederationExecution) {
1045 if (!createJoinFederationExecution())
1051 // Read the xml file containing the object model
1052 if (!readObjectModel()) {
1056 // start being time constrained if required
1057 if (_timeConstrained) {
1058 if (!enableTimeConstrained()) {
1063 // Now that we are potentially time constrained, we can subscribe.
1064 // This is to make sure we do not get any time stamped message
1065 // converted to a non time stamped message by the rti.
1070 // Before we publish anything start getting regulating if required
1071 if (_timeRegulating) {
1072 if (!enableTimeRegulation()) {
1077 // Note that starting from here, we need to be careful with things
1078 // requireing unbounded time. The rest of the federation might wait
1079 // for us to finish!
1081 // Compute the time offset from the system time to the simulation time
1082 if (_timeConstrainedByLocalClock) {
1083 if (!enableTimeConstrainedByLocalClock()) {
1084 SG_LOG(SG_NETWORK, SG_WARN, "Cannot enable time constrained by local clock!");
1090 // Publish what we want to write
1100 HLAFederate::update()
1102 if (_timeIncrement <= SGTimeStamp::fromSec(0))
1103 return processMessages();
1105 return timeAdvanceBy(_timeIncrement);
1109 HLAFederate::shutdown()
1111 // On shutdown, just try all in order.
1112 // If something goes wrong, continue and try to get out here as good as possible.
1115 if (_createFederationExecution) {
1116 if (!resignDestroyFederationExecution())
1135 while (!getDone()) {
1149 HLAFederate::_clearRTI()
1151 for (InteractionClassMap::iterator i = _interactionClassMap.begin(); i != _interactionClassMap.end(); ++i)
1152 i->second->_clearRTIInteractionClass();
1153 for (ObjectInstanceMap::iterator i = _objectInstanceMap.begin(); i != _objectInstanceMap.end(); ++i)
1154 i->second->_clearRTIObjectInstance();
1155 for (ObjectClassMap::iterator i = _objectClassMap.begin(); i != _objectClassMap.end(); ++i)
1156 i->second->_clearRTIObjectClass();
1162 HLAFederate::_insertInteractionClass(HLAInteractionClass* interactionClass)
1164 if (!interactionClass)
1166 if (_interactionClassMap.find(interactionClass->getName()) != _interactionClassMap.end()) {
1167 SG_LOG(SG_IO, SG_ALERT, "HLA: _insertInteractionClass: object instance with name \""
1168 << interactionClass->getName() << "\" already known to federate!");
1171 _interactionClassMap.insert(InteractionClassMap::value_type(interactionClass->getName(), interactionClass));
1176 HLAFederate::_insertObjectClass(HLAObjectClass* objectClass)
1180 if (_objectClassMap.find(objectClass->getName()) != _objectClassMap.end()) {
1181 SG_LOG(SG_IO, SG_ALERT, "HLA: _insertObjectClass: object instance with name \""
1182 << objectClass->getName() << "\" already known to federate!");
1185 _objectClassMap.insert(ObjectClassMap::value_type(objectClass->getName(), objectClass));
1190 HLAFederate::_insertObjectInstance(HLAObjectInstance* objectInstance)
1192 if (!objectInstance)
1194 if (objectInstance->getName().empty()) {
1195 SG_LOG(SG_IO, SG_ALERT, "HLA: _insertObjectInstance: trying to insert object instance with empty name!");
1198 if (_objectInstanceMap.find(objectInstance->getName()) != _objectInstanceMap.end()) {
1199 SG_LOG(SG_IO, SG_WARN, "HLA: _insertObjectInstance: object instance with name \""
1200 << objectInstance->getName() << "\" already known to federate!");
1203 _objectInstanceMap.insert(ObjectInstanceMap::value_type(objectInstance->getName(), objectInstance));
1208 HLAFederate::_eraseObjectInstance(const std::string& name)
1210 ObjectInstanceMap::iterator i = _objectInstanceMap.find(name);
1211 if (i == _objectInstanceMap.end()) {
1212 SG_LOG(SG_IO, SG_WARN, "HLA: _eraseObjectInstance: object instance with name \""
1213 << name << "\" not known to federate!");
1216 _objectInstanceMap.erase(i);
1219 } // namespace simgear