}
while (!_rtiFederate->getTimeConstrainedEnabled()) {
- _rtiFederate->processMessage();
+ if (RTIFederate::ProcessMessageFatal == _rtiFederate->processMessage()) {
+ SG_LOG(SG_NETWORK, SG_WARN, "HLA: Fatal error on processing messages!");
+ return false;
+ }
}
return true;
}
while (!_rtiFederate->getTimeRegulationEnabled()) {
- _rtiFederate->processMessage();
+ if (RTIFederate::ProcessMessageFatal == _rtiFederate->processMessage()) {
+ SG_LOG(SG_NETWORK, SG_WARN, "HLA: Fatal error on processing messages!");
+ return false;
+ }
}
return true;
SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!");
return false;
}
- return _rtiFederate->processMessage();
+
+ if (RTIFederate::ProcessMessageFatal == _rtiFederate->processMessage()) {
+ SG_LOG(SG_NETWORK, SG_WARN, "HLA: Fatal error on processing messages!");
+ return false;
+ }
+ return true;
}
bool
SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!");
return false;
}
- return _rtiFederate->processMessages(timeout.toSecs(), 0);
+
+ if (RTIFederate::ProcessMessageFatal == _rtiFederate->processMessages(timeout.toSecs(), 0)) {
+ SG_LOG(SG_NETWORK, SG_WARN, "HLA: Fatal error on processing messages!");
+ return false;
+ }
+ return true;
}
bool
}
while (_rtiFederate->getTimeAdvancePending()) {
- _rtiFederate->processMessage();
+ if (RTIFederate::ProcessMessageFatal == _rtiFederate->processMessage()) {
+ SG_LOG(SG_NETWORK, SG_WARN, "HLA: Fatal error on processing messages!");
+ return false;
+ }
}
if (_timeConstrainedByLocalClock) {
double rest = (systemTime - SGTimeStamp::now()).toSecs();
if (rest < 0)
break;
- _rtiFederate->processMessages(rest, rest);
+ if (RTIFederate::ProcessMessageFatal == _rtiFederate->processMessages(rest, rest)) {
+ SG_LOG(SG_NETWORK, SG_WARN, "HLA: Fatal error on processing messages!");
+ return false;
+ }
}
}
// Now flush just what is left
- while (_rtiFederate->processMessages(0, 0));
-
- return true;
-}
-
-bool
-HLAFederate::tick(const double& minimum, const double& maximum)
-{
- if (!_rtiFederate.valid()) {
- SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!");
- return false;
- }
- return _rtiFederate->processMessages(minimum, maximum);
-}
-
-bool
-HLAFederate::readObjectModelTemplate(const std::string& objectModel,
- HLAFederate::ObjectModelFactory& objectModelFactory)
-{
- // The XML version of the federate object model.
- // This one covers the generic attributes, parameters and data types.
- HLAOMTXmlVisitor omtXmlVisitor;
- try {
- readXML(objectModel, omtXmlVisitor);
- } catch (const sg_throwable& e) {
- SG_LOG(SG_IO, SG_ALERT, "Could not open HLA XML object model file: "
- << e.getMessage());
- return false;
- } catch (...) {
- SG_LOG(SG_IO, SG_ALERT, "Could not open HLA XML object model file");
- return false;
- }
-
- omtXmlVisitor.setDataTypesToFederate(*this);
-
- unsigned numObjectClasses = omtXmlVisitor.getNumObjectClasses();
- for (unsigned i = 0; i < numObjectClasses; ++i) {
- const HLAOMTXmlVisitor::ObjectClass* objectClass = omtXmlVisitor.getObjectClass(i);
- std::string objectClassName = objectClass->getName();
-
- SGSharedPtr<HLAObjectClass> hlaObjectClass = objectModelFactory.createObjectClass(objectClassName, *this);
- if (!hlaObjectClass.valid()) {
- SG_LOG(SG_IO, SG_INFO, "Ignoring object class \"" << objectClassName << "\".");
- continue;
- }
-
- bool publish = objectModelFactory.publishObjectClass(objectClassName, objectClass->getSharing());
- bool subscribe = objectModelFactory.subscribeObjectClass(objectClassName, objectClass->getSharing());
-
- // process the attributes
- for (unsigned j = 0; j < objectClass->getNumAttributes(); ++j) {
- const simgear::HLAOMTXmlVisitor::Attribute* attribute;
- attribute = objectClass->getAttribute(j);
-
- std::string attributeName = attribute->getName();
- unsigned index = hlaObjectClass->addAttribute(attributeName);
-
- if (index == ~0u) {
- SG_LOG(SG_IO, SG_WARN, "RTI does not know the \"" << attributeName << "\" attribute!");
- continue;
- }
-
- // the attributes datatype
- SGSharedPtr<const HLADataType> dataType = getDataType(attribute->getDataType());
- if (!dataType.valid()) {
- SG_LOG(SG_IO, SG_WARN, "Could not find data type for attribute \""
- << attributeName << "\" in object class \"" << objectClassName << "\"!");
- }
- hlaObjectClass->setAttributeDataType(index, dataType);
- hlaObjectClass->setAttributeUpdateType(index, attribute->getUpdateType());
- if (subscribe && objectModelFactory.subscribeAttribute(objectClassName, attributeName, attribute->_sharing))
- hlaObjectClass->setAttributeSubscriptionType(index, attribute->getSubscriptionType());
- if (publish && objectModelFactory.publishAttribute(objectClassName, attributeName, attribute->_sharing))
- hlaObjectClass->setAttributePublicationType(index, attribute->getPublicationType());
+ while (true) {
+ RTIFederate::ProcessMessageResult result = _rtiFederate->processMessages(0, 0);
+ if (RTIFederate::ProcessMessageLast == result)
+ break;
+ if (RTIFederate::ProcessMessageFatal == result) {
+ SG_LOG(SG_NETWORK, SG_WARN, "HLA: Fatal error on processing messages!");
+ return false;
}
-
- if (publish)
- hlaObjectClass->publish();
- if (subscribe)
- hlaObjectClass->subscribe();
-
}
- return resolveObjectModel();
+ return true;
}
bool
HLAFederate::readRTI13ObjectModelTemplate(const std::string& objectModel)
{
- SG_LOG(SG_IO, SG_ALERT, "HLA version RTI13 not yet(!?) supported.");
+ SG_LOG(SG_IO, SG_WARN, "HLA version RTI13 not yet(!?) supported.");
return false;
}
bool
HLAFederate::readRTI1516EObjectModelTemplate(const std::string& objectModel)
{
- SG_LOG(SG_IO, SG_ALERT, "HLA version RTI1516E not yet(!?) supported.");
+ SG_LOG(SG_IO, SG_WARN, "HLA version RTI1516E not yet(!?) supported.");
return false;
}
bool
HLAFederate::update()
{
- return timeAdvanceBy(_timeIncrement);
+ if (_timeIncrement <= SGTimeStamp::fromSec(0))
+ return processMessages();
+ else
+ return timeAdvanceBy(_timeIncrement);
}
bool
}
bool
-HLAFederate::_insertInteractionClass(const SGSharedPtr<HLAInteractionClass>& interactionClass)
+HLAFederate::_insertInteractionClass(HLAInteractionClass* interactionClass)
{
- if (!interactionClass.valid())
+ if (!interactionClass)
return false;
if (_interactionClassMap.find(interactionClass->getName()) != _interactionClassMap.end()) {
SG_LOG(SG_IO, SG_ALERT, "HLA: _insertInteractionClass: object instance with name \""
}
bool
-HLAFederate::_insertObjectClass(const SGSharedPtr<HLAObjectClass>& objectClass)
+HLAFederate::_insertObjectClass(HLAObjectClass* objectClass)
{
- if (!objectClass.valid())
+ if (!objectClass)
return false;
if (_objectClassMap.find(objectClass->getName()) != _objectClassMap.end()) {
SG_LOG(SG_IO, SG_ALERT, "HLA: _insertObjectClass: object instance with name \""
}
bool
-HLAFederate::_insertObjectInstance(const SGSharedPtr<HLAObjectInstance>& objectInstance)
+HLAFederate::_insertObjectInstance(HLAObjectInstance* objectInstance)
{
- if (!objectInstance.valid())
+ if (!objectInstance)
return false;
if (objectInstance->getName().empty()) {
SG_LOG(SG_IO, SG_ALERT, "HLA: _insertObjectInstance: trying to insert object instance with empty name!");
projects / simgear.git / blobdiff