diff --git a/simgear/hla/HLAFederate.cxx b/simgear/hla/HLAFederate.cxx index 59a5f4b0..fa1cc576 100644 --- a/simgear/hla/HLAFederate.cxx +++ b/simgear/hla/HLAFederate.cxx @@ -35,24 +35,106 @@ HLAFederate::~HLAFederate() { } -std::string -HLAFederate::getFederateType() const +HLAFederate::Version +HLAFederate::getVersion() const { - if (!_rtiFederate.valid()) { - SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!"); - return std::string(); - } - return _rtiFederate->getFederateType(); + return _version; } -std::string -HLAFederate::getFederationName() const +bool +HLAFederate::setVersion(HLAFederate::Version version) { - if (!_rtiFederate.valid()) { - SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!"); - return std::string(); + if (_rtiFederate.valid()) { + SG_LOG(SG_NETWORK, SG_ALERT, "HLA: Ignoring HLAFederate parameter setting on already connected federate!"); + return false; } - return _rtiFederate->getFederationName(); + _version = version; + return true; +} + +const std::list& +HLAFederate::getConnectArguments() const +{ + return _connectArguments; +} + +bool +HLAFederate::setConnectArguments(const std::list& connectArguments) +{ + if (_rtiFederate.valid()) { + SG_LOG(SG_NETWORK, SG_ALERT, "HLA: Ignoring HLAFederate parameter setting on already connected federate!"); + return false; + } + _connectArguments = connectArguments; + return true; +} + +const std::string& +HLAFederate::getFederationExecutionName() const +{ + return _federationExecutionName; +} + +bool +HLAFederate::setFederationExecutionName(const std::string& federationExecutionName) +{ + if (_rtiFederate.valid()) { + SG_LOG(SG_NETWORK, SG_ALERT, "HLA: Ignoring HLAFederate parameter setting on already connected federate!"); + return false; + } + _federationExecutionName = federationExecutionName; + return true; +} + +const std::string& +HLAFederate::getFederationObjectModel() const +{ + return _federationObjectModel; +} + +bool +HLAFederate::setFederationObjectModel(const std::string& federationObjectModel) +{ + if (_rtiFederate.valid()) { + SG_LOG(SG_NETWORK, SG_ALERT, "HLA: Ignoring HLAFederate parameter setting on already connected federate!"); + return false; + } + _federationObjectModel = federationObjectModel; + return true; +} + +const std::string& +HLAFederate::getFederateType() const +{ + return _federateType; +} + +bool +HLAFederate::setFederateType(const std::string& federateType) +{ + if (_rtiFederate.valid()) { + SG_LOG(SG_NETWORK, SG_ALERT, "HLA: Ignoring HLAFederate parameter setting on already connected federate!"); + return false; + } + _federateType = federateType; + return true; +} + +const std::string& +HLAFederate::getFederateName() const +{ + return _federateName; +} + +bool +HLAFederate::setFederateName(const std::string& federateName) +{ + if (_rtiFederate.valid()) { + SG_LOG(SG_NETWORK, SG_ALERT, "HLA: Ignoring HLAFederate parameter setting on already connected federate!"); + return false; + } + _federateName = federateName; + return true; } bool @@ -65,6 +147,8 @@ HLAFederate::connect(Version version, const std::list& stringList) switch (version) { case RTI13: _rtiFederate = new RTI13Federate(stringList); + _version = version; + _connectArguments = stringList; break; case RTI1516: SG_LOG(SG_IO, SG_ALERT, "HLA version RTI1516 not yet(!?) supported."); @@ -80,6 +164,31 @@ HLAFederate::connect(Version version, const std::list& stringList) return _rtiFederate.valid(); } +bool +HLAFederate::connect() +{ + if (_rtiFederate.valid()) { + SG_LOG(SG_NETWORK, SG_WARN, "HLA: Trying to connect to already connected federate!"); + return false; + } + switch (_version) { + case RTI13: + _rtiFederate = new RTI13Federate(_connectArguments); + break; + case RTI1516: + SG_LOG(SG_IO, SG_ALERT, "HLA version RTI1516 not yet(!?) supported."); + // _rtiFederate = new RTI1516Federate(_connectArguments); + break; + case RTI1516E: + SG_LOG(SG_IO, SG_ALERT, "HLA version RTI1516E not yet(!?) supported."); + // _rtiFederate = new RTI1516eFederate(_connectArguments); + break; + default: + SG_LOG(SG_NETWORK, SG_WARN, "HLA: Unknown rti version in connect!"); + } + return _rtiFederate.valid(); +} + bool HLAFederate::disconnect() { @@ -98,7 +207,15 @@ HLAFederate::createFederationExecution(const std::string& federation, const std: SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!"); return false; } - return _rtiFederate->createFederationExecution(federation, objectModel); + + RTIFederate::FederationManagementResult createResult; + createResult = _rtiFederate->createFederationExecution(federation, objectModel); + if (createResult == RTIFederate::FederationManagementFatal) + return false; + + _federationExecutionName = federation; + _federationObjectModel = objectModel; + return true; } bool @@ -108,7 +225,45 @@ HLAFederate::destroyFederationExecution(const std::string& federation) SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!"); return false; } - return _rtiFederate->destroyFederationExecution(federation); + + RTIFederate::FederationManagementResult destroyResult; + destroyResult = _rtiFederate->destroyFederationExecution(federation); + if (destroyResult == RTIFederate::FederationManagementFatal) + return false; + + return true; +} + +bool +HLAFederate::createFederationExecution() +{ + if (!_rtiFederate.valid()) { + SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!"); + return false; + } + + RTIFederate::FederationManagementResult createResult; + createResult = _rtiFederate->createFederationExecution(_federationExecutionName, _federationObjectModel); + if (createResult != RTIFederate::FederationManagementSuccess) + return false; + + return true; +} + +bool +HLAFederate::destroyFederationExecution() +{ + if (!_rtiFederate.valid()) { + SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!"); + return false; + } + + RTIFederate::FederationManagementResult destroyResult; + destroyResult = _rtiFederate->destroyFederationExecution(_federationExecutionName); + if (destroyResult != RTIFederate::FederationManagementSuccess) + return false; + + return true; } bool @@ -118,7 +273,29 @@ HLAFederate::join(const std::string& federateType, const std::string& federation SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!"); return false; } - return _rtiFederate->join(federateType, federation); + + RTIFederate::FederationManagementResult joinResult; + joinResult = _rtiFederate->join(federateType, federation); + if (joinResult == RTIFederate::FederationManagementFatal) + return false; + + return true; +} + +bool +HLAFederate::join() +{ + if (!_rtiFederate.valid()) { + SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!"); + return false; + } + + RTIFederate::FederationManagementResult joinResult; + joinResult = _rtiFederate->join(_federateType, _federationExecutionName); + if (joinResult != RTIFederate::FederationManagementSuccess) + return false; + + return true; } bool @@ -131,6 +308,61 @@ HLAFederate::resign() return _rtiFederate->resign(); } +bool +HLAFederate::createJoinFederationExecution() +{ + if (!_rtiFederate.valid()) { + SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!"); + return false; + } + + for (;;) { + // Try to join. + RTIFederate::FederationManagementResult joinResult; + joinResult = _rtiFederate->join(_federateType, _federationExecutionName); + switch (joinResult) { + case RTIFederate::FederationManagementSuccess: + // Fast return on success + return true; + case RTIFederate::FederationManagementFatal: + // Abort on fatal errors + return false; + default: + break; + }; + + // If not already joinable, try to create the requested federation + RTIFederate::FederationManagementResult createResult; + createResult = _rtiFederate->createFederationExecution(_federationExecutionName, _federationObjectModel); + switch (createResult) { + case RTIFederate::FederationManagementFatal: + // Abort on fatal errors + return false; + default: + // Try again to join + break; + } + } +} + +bool +HLAFederate::resignDestroyFederationExecution() +{ + if (!_rtiFederate.valid()) { + SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!"); + return false; + } + + // Resign ourselves + bool success = _rtiFederate->resign(); + + // and try to destroy, non fatal if still some federates joined + if (_rtiFederate->destroyFederationExecution(_federationExecutionName) == RTIFederate::FederationManagementFatal) + success = false; + + return success; +} + bool HLAFederate::enableTimeConstrained() { diff --git a/simgear/hla/HLAFederate.hxx b/simgear/hla/HLAFederate.hxx index 5af83396..f3b84afe 100644 --- a/simgear/hla/HLAFederate.hxx +++ b/simgear/hla/HLAFederate.hxx @@ -32,33 +32,55 @@ class RTIFederate; class HLAFederate : public SGWeakReferenced { public: + HLAFederate(); + virtual ~HLAFederate(); + enum Version { RTI13, RTI1516, RTI1516E }; - HLAFederate(); - virtual ~HLAFederate(); + Version getVersion() const; + bool setVersion(HLAFederate::Version version); + + const std::list& getConnectArguments() const; + bool setConnectArguments(const std::list& connectArguments); + + const std::string& getFederationExecutionName() const; + bool setFederationExecutionName(const std::string& federationExecutionName); + + const std::string& getFederationObjectModel() const; + bool setFederationObjectModel(const std::string& federationObjectModel); + + const std::string& getFederateType() const; + bool setFederateType(const std::string& federateType); + + const std::string& getFederateName() const; + bool setFederateName(const std::string& federateName); /// connect to an rti bool connect(Version version, const std::list& stringList); + bool connect(); bool disconnect(); - /// Get the name of the joined federate/federation - std::string getFederateType() const; - std::string getFederationName() const; - /// Create a federation execution /// Semantically this methods should be static, /// but the nonstatic case could reuse the connection to the server - /// FIXME: cannot determine from the return value if we created the execution bool createFederationExecution(const std::string& federation, const std::string& objectModel); bool destroyFederationExecution(const std::string& federation); + bool createFederationExecution(); + bool destroyFederationExecution(); /// Join with federateType the federation execution bool join(const std::string& federateType, const std::string& federation); + bool join(); bool resign(); + + /// Try to create and join the federation execution. + bool createJoinFederationExecution(); + bool resignDestroyFederationExecution(); + bool enableTimeConstrained(); bool disableTimeConstrained(); @@ -108,6 +130,14 @@ public: private: SGSharedPtr _rtiFederate; + Version _version; + std::list _connectArguments; + + std::string _federationExecutionName; + std::string _federationObjectModel; + std::string _federateType; + std::string _federateName; + typedef std::map > ObjectClassMap; ObjectClassMap _objectClassMap; diff --git a/simgear/hla/HLAInteractionClass.hxx b/simgear/hla/HLAInteractionClass.hxx index c45c22d7..021dff7e 100644 --- a/simgear/hla/HLAInteractionClass.hxx +++ b/simgear/hla/HLAInteractionClass.hxx @@ -25,6 +25,10 @@ class RTIInteractionClass; class HLAInteractionClass : public SGWeakReferenced { public: virtual ~HLAInteractionClass() {} + +private: + HLAInteractionClass(const HLAInteractionClass&); + HLAInteractionClass& operator=(const HLAInteractionClass&); }; } // namespace simgear diff --git a/simgear/hla/HLAObjectClass.hxx b/simgear/hla/HLAObjectClass.hxx index b0db5ad1..3c5ace5f 100644 --- a/simgear/hla/HLAObjectClass.hxx +++ b/simgear/hla/HLAObjectClass.hxx @@ -95,6 +95,9 @@ protected: virtual HLAObjectInstance* createObjectInstance(RTIObjectInstance* rtiObjectInstance); private: + HLAObjectClass(const HLAObjectClass&); + HLAObjectClass& operator=(const HLAObjectClass&); + // The internal entry points from the RTILObjectClass callback functions void discoverInstance(RTIObjectInstance* objectInstance, const RTIData& tag); void removeInstance(HLAObjectInstance& objectInstance, const RTIData& tag); diff --git a/simgear/hla/HLAPropertyDataElement.hxx b/simgear/hla/HLAPropertyDataElement.hxx index 4441584e..32dba058 100644 --- a/simgear/hla/HLAPropertyDataElement.hxx +++ b/simgear/hla/HLAPropertyDataElement.hxx @@ -151,7 +151,7 @@ class HLAPropertyDataElement : public HLADataElement { public: HLAPropertyDataElement(HLAPropertyReference* propertyReference); HLAPropertyDataElement(const simgear::HLADataType* dataType, HLAPropertyReference* propertyReference); - ~HLAPropertyDataElement(); + virtual ~HLAPropertyDataElement(); virtual bool encode(HLAEncodeStream& stream) const; virtual bool decode(HLADecodeStream& stream); diff --git a/simgear/hla/RTI13Ambassador.hxx b/simgear/hla/RTI13Ambassador.hxx index 5446f858..0723ac47 100644 --- a/simgear/hla/RTI13Ambassador.hxx +++ b/simgear/hla/RTI13Ambassador.hxx @@ -15,8 +15,8 @@ // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -#ifndef RTIAmbassador_hxx -#define RTIAmbassador_hxx +#ifndef RTI13Ambassador_hxx +#define RTI13Ambassador_hxx #include #include @@ -45,58 +45,20 @@ namespace simgear { -class RTI13Ambassador : public SGWeakReferenced { +class RTI13Federate; + +class RTI13Ambassador : public SGReferenced { public: - RTI13Ambassador() : - _federateAmbassador(*this), - _timeRegulationEnabled(false), - _timeConstrainedEnabled(false), - _timeAdvancePending(false) + ~RTI13Ambassador() { } - virtual ~RTI13Ambassador() - { } - - // processes the queues that filled up during the past - void processQueues() - { - while (!_queueCallbackList.empty()) { - (*_queueCallbackList.front())(); - _queueCallbackList.pop_front(); - } - - while (!_objectInstancePendingCallbackList.empty()) { - (*_objectInstancePendingCallbackList.begin())->flushPendingRequests(); - _objectInstancePendingCallbackList.erase(_objectInstancePendingCallbackList.begin()); - } - } - - bool getTimeRegulationEnabled() const - { return _timeRegulationEnabled; } - bool getTimeConstrainedEnabled() const - { return _timeConstrainedEnabled; } - bool getTimeAdvancePending() const - { return _timeAdvancePending; } - const SGTimeStamp& getCurrentLogicalTime() const - { return _federateTime; } - - bool getFederationSynchronizationPointAnnounced(const std::string& label) - { return _pendingSyncLabels.find(label) != _pendingSyncLabels.end(); } - bool getFederationSynchronized(const std::string& label) - { - std::set::iterator i = _syncronizedSyncLabels.find(label); - if (i == _syncronizedSyncLabels.end()) - return false; - _syncronizedSyncLabels.erase(i); - return true; - } void createFederationExecution(const std::string& name, const std::string& objectModel) { _rtiAmbassador.createFederationExecution(name.c_str(), objectModel.c_str()); } void destroyFederationExecution(const std::string& name) { _rtiAmbassador.destroyFederationExecution(name.c_str()); } - RTI::FederateHandle joinFederationExecution(const std::string& federate, const std::string& federation) - { return _rtiAmbassador.joinFederationExecution(federate.c_str(), federation.c_str(), &_federateAmbassador); } + RTI::FederateHandle joinFederationExecution(const std::string& federate, const std::string& federation, RTI::FederateAmbassador* federateAmbassador) + { return _rtiAmbassador.joinFederationExecution(federate.c_str(), federation.c_str(), federateAmbassador); } void resignFederationExecution() { _rtiAmbassador.resignFederationExecution(RTI::DELETE_OBJECTS_AND_RELEASE_ATTRIBUTES); } @@ -114,13 +76,8 @@ public: void unsubscribeObjectClass(const RTI::ObjectClassHandle& handle) { _rtiAmbassador.unsubscribeObjectClass(handle); } - RTI13ObjectInstance* registerObjectInstance(const RTI13ObjectClass* objectClass, HLAObjectInstance* hlaObjectInstance) - { - RTI::ObjectHandle objectHandle = _rtiAmbassador.registerObjectInstance(objectClass->getHandle()); - RTI13ObjectInstance* objectInstance = new RTI13ObjectInstance(objectHandle, hlaObjectInstance, objectClass, this, true); - _objectInstanceMap[objectHandle] = objectInstance; - return objectInstance; - } + RTI::ObjectHandle registerObjectInstance(const RTI::ObjectClassHandle& handle) + { return _rtiAmbassador.registerObjectInstance(handle); } void updateAttributeValues(const RTI::ObjectHandle& objectHandle, const RTI::AttributeHandleValuePairSet& attributeValues, const SGTimeStamp& timeStamp, const RTIData& tag) { _rtiAmbassador.updateAttributeValues(objectHandle, attributeValues, toFedTime(timeStamp), tag.data()); } @@ -133,38 +90,11 @@ public: // { _rtiAmbassador.sendInteraction(interactionClassHandle, parameters, tag.data()); } void deleteObjectInstance(const RTI::ObjectHandle& objectHandle, const SGTimeStamp& timeStamp, const RTIData& tag) - { - RTI::EventRetractionHandle h = _rtiAmbassador.deleteObjectInstance(objectHandle, toFedTime(timeStamp), tag.data()); - ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle); - if (i == _objectInstanceMap.end()) { - SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: ObjectInstance not found."); - return; - } - _objectInstancePendingCallbackList.erase(i->second); - _objectInstanceMap.erase(i); - } + { RTI::EventRetractionHandle h = _rtiAmbassador.deleteObjectInstance(objectHandle, toFedTime(timeStamp), tag.data()); } void deleteObjectInstance(const RTI::ObjectHandle& objectHandle, const RTIData& tag) - { - _rtiAmbassador.deleteObjectInstance(objectHandle, tag.data()); - ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle); - if (i == _objectInstanceMap.end()) { - SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: ObjectInstance not found."); - return; - } - _objectInstancePendingCallbackList.erase(i->second); - _objectInstanceMap.erase(i); - } + { _rtiAmbassador.deleteObjectInstance(objectHandle, tag.data()); } void localDeleteObjectInstance(const RTI::ObjectHandle& objectHandle) - { - _rtiAmbassador.localDeleteObjectInstance(objectHandle); - ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle); - if (i == _objectInstanceMap.end()) { - SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: ObjectInstance not found."); - return; - } - _objectInstancePendingCallbackList.erase(i->second); - _objectInstanceMap.erase(i); - } + { _rtiAmbassador.localDeleteObjectInstance(objectHandle); } void requestObjectAttributeValueUpdate(const RTI::ObjectHandle& handle, const RTI::AttributeHandleSet& attributeHandleSet) { _rtiAmbassador.requestObjectAttributeValueUpdate(handle, attributeHandleSet); } @@ -351,36 +281,45 @@ public: /// Time Management - void enableTimeRegulation(const SGTimeStamp& federateTime, const SGTimeStamp& lookahead) - { _rtiAmbassador.enableTimeRegulation(toFedTime(federateTime), toFedTime(lookahead)); } + void enableTimeRegulation(const SGTimeStamp& lookahead) + { + RTIfedTime federateTime; + federateTime.setZero(); + _rtiAmbassador.enableTimeRegulation(federateTime, toFedTime(lookahead)); + } void disableTimeRegulation() - { _rtiAmbassador.disableTimeRegulation(); _timeRegulationEnabled = false; } + { _rtiAmbassador.disableTimeRegulation();} void enableTimeConstrained() { _rtiAmbassador.enableTimeConstrained(); } void disableTimeConstrained() - { _rtiAmbassador.disableTimeConstrained(); _timeConstrainedEnabled = false; } + { _rtiAmbassador.disableTimeConstrained(); } void timeAdvanceRequest(const SGTimeStamp& time) - { _rtiAmbassador.timeAdvanceRequest(toFedTime(time)); _timeAdvancePending = true; } + { _rtiAmbassador.timeAdvanceRequest(toFedTime(time)); } void timeAdvanceRequestAvailable(const SGTimeStamp& time) - { _rtiAmbassador.timeAdvanceRequestAvailable(toFedTime(time)); _timeAdvancePending = true; } + { _rtiAmbassador.timeAdvanceRequestAvailable(toFedTime(time)); } - // bool queryLBTS(double& time) - // { - // try { - // RTIfedTime fedTime; - // _rtiAmbassador.queryLBTS(fedTime); - // time = fedTime.getTime(); - // return true; - // } catch (RTI::FederateNotExecutionMember& e) { - // } catch (RTI::ConcurrentAccessAttempted& e) { - // } catch (RTI::SaveInProgress& e) { - // } catch (RTI::RestoreInProgress& e) { - // } catch (RTI::RTIinternalError& e) { - // } - // return false; - // } + bool queryGALT(SGTimeStamp& timeStamp) + { + RTIfedTime fedTime; + fedTime.setPositiveInfinity(); + _rtiAmbassador.queryLBTS(fedTime); + if (fedTime.isPositiveInfinity()) + return false; + timeStamp = toTimeStamp(fedTime); + return true; + } + bool queryLITS(SGTimeStamp& timeStamp) + { + RTIfedTime fedTime; + fedTime.setPositiveInfinity(); + _rtiAmbassador.queryMinNextEventTime(fedTime); + if (fedTime.isPositiveInfinity()) + return false; + timeStamp = toTimeStamp(fedTime); + return true; + } void queryFederateTime(SGTimeStamp& timeStamp) { RTIfedTime fedTime; @@ -396,19 +335,6 @@ public: timeStamp = toTimeStamp(fedTime); } - RTI13ObjectClass* createObjectClass(const std::string& name, HLAObjectClass* hlaObjectClass) - { - RTI::ObjectClassHandle objectClassHandle; - objectClassHandle = getObjectClassHandle(name); - if (_objectClassMap.find(objectClassHandle) != _objectClassMap.end()) { - SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not create object class, object class already exists!"); - return 0; - } - RTI13ObjectClass* rtiObjectClass; - rtiObjectClass = new RTI13ObjectClass(hlaObjectClass, objectClassHandle, this); - _objectClassMap[objectClassHandle] = rtiObjectClass; - return rtiObjectClass; - } RTI::ObjectClassHandle getObjectClassHandle(const std::string& name) { return _rtiAmbassador.getObjectClassHandle(name.c_str()); } std::string getObjectClassName(const RTI::ObjectClassHandle& handle) @@ -469,17 +395,6 @@ public: // return parameterName; // } - RTI13ObjectInstance* getObjectInstance(const std::string& name) - { - RTI::ObjectHandle objectHandle; - objectHandle = getObjectInstanceHandle(name); - ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle); - if (i == _objectInstanceMap.end()) { - SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: ObjectInstance not found."); - return 0; - } - return i->second; - } RTI::ObjectHandle getObjectInstanceHandle(const std::string& name) { return _rtiAmbassador.getObjectInstanceHandle(name.c_str()); } std::string getObjectInstanceName(const RTI::ObjectHandle& objectHandle) @@ -535,498 +450,6 @@ public: bool tick(double minimum, double maximum) { return _rtiAmbassador.tick(minimum, maximum); } - void addObjectInstanceForCallback(RTIObjectInstance* objectIntance) - { _objectInstancePendingCallbackList.insert(objectIntance); } - -private: - /// Generic callback to execute some notification on objects in a way that they are not prone to - /// ConcurrentAccess exceptions. - class QueueCallback : public SGReferenced { - public: - virtual ~QueueCallback() {} - virtual void operator()() = 0; - }; - - class RemoveObjectCallback : public QueueCallback { - public: - RemoveObjectCallback(SGSharedPtr objectInstance, const RTIData& tag) : - _objectInstance(objectInstance), - _tag(tag) - { } - virtual void operator()() - { - _objectInstance->removeInstance(_tag); - } - private: - SGSharedPtr _objectInstance; - RTIData _tag; - }; - - /// Just the interface class doing the callbacks into the parent class - struct FederateAmbassador : public RTI::FederateAmbassador { - FederateAmbassador(RTI13Ambassador& rtiAmbassador) : - _rtiAmbassador(rtiAmbassador) - { - } - virtual ~FederateAmbassador() - throw (RTI::FederateInternalError) - { - } - - /// RTI federate ambassador callback functions. - virtual void synchronizationPointRegistrationSucceeded(const char* label) - throw (RTI::FederateInternalError) - { - } - - virtual void synchronizationPointRegistrationFailed(const char* label) - throw (RTI::FederateInternalError) - { - } - - virtual void announceSynchronizationPoint(const char* label, const char* tag) - throw (RTI::FederateInternalError) - { - _rtiAmbassador._pendingSyncLabels.insert(toStdString(label)); - } - - virtual void federationSynchronized(const char* label) - throw (RTI::FederateInternalError) - { - std::string s = toStdString(label); - _rtiAmbassador._pendingSyncLabels.erase(s); - _rtiAmbassador._syncronizedSyncLabels.insert(s); - } - - virtual void initiateFederateSave(const char* label) - throw (RTI::UnableToPerformSave, - RTI::FederateInternalError) - { - } - - virtual void federationSaved() - throw (RTI::FederateInternalError) - { - } - - virtual void federationNotSaved() - throw (RTI::FederateInternalError) - { - } - - virtual void requestFederationRestoreSucceeded(const char* label) - throw (RTI::FederateInternalError) - { - } - - virtual void requestFederationRestoreFailed(const char* label, const char* reason) - throw (RTI::FederateInternalError) - { - } - - virtual void federationRestoreBegun() - throw (RTI::FederateInternalError) - { - } - - virtual void initiateFederateRestore(const char* label, RTI::FederateHandle federateHandle) - throw (RTI::SpecifiedSaveLabelDoesNotExist, - RTI::CouldNotRestore, - RTI::FederateInternalError) - { - } - - virtual void federationRestored() - throw (RTI::FederateInternalError) - { - } - - virtual void federationNotRestored() - throw (RTI::FederateInternalError) - { - } - - // Declaration Management - virtual void startRegistrationForObjectClass(RTI::ObjectClassHandle objectClassHandle) - throw (RTI::ObjectClassNotPublished, - RTI::FederateInternalError) - { - ObjectClassMap::iterator i = _rtiAmbassador._objectClassMap.find(objectClassHandle); - if (i == _rtiAmbassador._objectClassMap.end()) - return; - if (!i->second.valid()) - return; - i->second->startRegistration(); - } - - virtual void stopRegistrationForObjectClass(RTI::ObjectClassHandle objectClassHandle) - throw (RTI::ObjectClassNotPublished, - RTI::FederateInternalError) - { - ObjectClassMap::iterator i = _rtiAmbassador._objectClassMap.find(objectClassHandle); - if (i == _rtiAmbassador._objectClassMap.end()) - return; - if (!i->second.valid()) - return; - i->second->stopRegistration(); - } - - virtual void turnInteractionsOn(RTI::InteractionClassHandle interactionClassHandle) - throw (RTI::InteractionClassNotPublished, - RTI::FederateInternalError) - { - } - - virtual void turnInteractionsOff(RTI::InteractionClassHandle interactionClassHandle) - throw (RTI::InteractionClassNotPublished, - RTI::FederateInternalError) - { - } - - - // Object Management - virtual void discoverObjectInstance(RTI::ObjectHandle objectHandle, RTI::ObjectClassHandle objectClassHandle, const char* tag) - throw (RTI::CouldNotDiscover, - RTI::ObjectClassNotKnown, - RTI::FederateInternalError) - { - ObjectClassMap::iterator i = _rtiAmbassador._objectClassMap.find(objectClassHandle); - if (i == _rtiAmbassador._objectClassMap.end()) - throw RTI::ObjectClassNotKnown("Federate: discoverObjectInstance()!"); - if (!i->second.valid()) - return; - SGSharedPtr objectInstance = new RTI13ObjectInstance(objectHandle, 0, i->second, &_rtiAmbassador, false); - _rtiAmbassador._objectInstanceMap[objectHandle] = objectInstance; - _rtiAmbassador._objectInstancePendingCallbackList.insert(objectInstance); - i->second->discoverInstance(objectInstance.get(), tagToData(tag)); - } - - virtual void reflectAttributeValues(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleValuePairSet& attributeValuePairSet, - const RTI::FedTime& fedTime, const char* tag, RTI::EventRetractionHandle eventRetractionHandle) - throw (RTI::ObjectNotKnown, - RTI::AttributeNotKnown, - RTI::FederateOwnsAttributes, - RTI::InvalidFederationTime, - RTI::FederateInternalError) - { - ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle); - if (i == _rtiAmbassador._objectInstanceMap.end()) - throw RTI::ObjectNotKnown("Reflect attributes for unknown object!"); - if (!i->second.valid()) - return; - i->second->reflectAttributeValues(attributeValuePairSet, toTimeStamp(fedTime), tagToData(tag)); - } - - virtual void reflectAttributeValues(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleValuePairSet& attributeValuePairSet, - const char* tag) - throw (RTI::ObjectNotKnown, - RTI::AttributeNotKnown, - RTI::FederateOwnsAttributes, - RTI::FederateInternalError) - { - ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle); - if (i == _rtiAmbassador._objectInstanceMap.end()) - throw RTI::ObjectNotKnown("Reflect attributes for unknown object!"); - if (!i->second.valid()) - return; - i->second->reflectAttributeValues(attributeValuePairSet, tagToData(tag)); - } - - virtual void receiveInteraction(RTI::InteractionClassHandle interactionClassHandle, const RTI::ParameterHandleValuePairSet& parameters, - const RTI::FedTime& fedTime, const char* tag, RTI::EventRetractionHandle eventRetractionHandle) - throw (RTI::InteractionClassNotKnown, - RTI::InteractionParameterNotKnown, - RTI::InvalidFederationTime, - RTI::FederateInternalError) - { - } - - virtual void receiveInteraction(RTI::InteractionClassHandle interactionClassHandle, - const RTI::ParameterHandleValuePairSet& parameters, const char* tag) - throw (RTI::InteractionClassNotKnown, - RTI::InteractionParameterNotKnown, - RTI::FederateInternalError) - { - } - - virtual void removeObjectInstance(RTI::ObjectHandle objectHandle, const RTI::FedTime& fedTime, - const char* tag, RTI::EventRetractionHandle eventRetractionHandle) - throw (RTI::ObjectNotKnown, - RTI::InvalidFederationTime, - RTI::FederateInternalError) - { - ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle); - if (i == _rtiAmbassador._objectInstanceMap.end()) - throw RTI::ObjectNotKnown("Federate: removeObjectInstance()!"); - if (i->second.valid()) - _rtiAmbassador._queueCallbackList.push_back(new RemoveObjectCallback(i->second, tagToData(tag))); - _rtiAmbassador._objectInstancePendingCallbackList.erase(i->second); - _rtiAmbassador._objectInstanceMap.erase(i); - } - - virtual void removeObjectInstance(RTI::ObjectHandle objectHandle, const char* tag) - throw (RTI::ObjectNotKnown, - RTI::FederateInternalError) - { - ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle); - if (i == _rtiAmbassador._objectInstanceMap.end()) - throw RTI::ObjectNotKnown("Federate: removeObjectInstance()!"); - if (i->second.valid()) - _rtiAmbassador._queueCallbackList.push_back(new RemoveObjectCallback(i->second, tagToData(tag))); - _rtiAmbassador._objectInstancePendingCallbackList.erase(i->second); - _rtiAmbassador._objectInstanceMap.erase(i); - } - - virtual void attributesInScope(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes) - throw (RTI::ObjectNotKnown, - RTI::AttributeNotKnown, - RTI::FederateInternalError) - { - ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle); - if (i == _rtiAmbassador._objectInstanceMap.end()) - throw RTI::ObjectNotKnown("Attributes in scope for unknown object!"); - if (!i->second.valid()) - return; - i->second->attributesInScope(attributes); - } - - virtual void attributesOutOfScope(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes) - throw (RTI::ObjectNotKnown, - RTI::AttributeNotKnown, - RTI::FederateInternalError) - { - ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle); - if (i == _rtiAmbassador._objectInstanceMap.end()) - throw RTI::ObjectNotKnown("Attributes in scope for unknown object!"); - if (!i->second.valid()) - return; - i->second->attributesOutOfScope(attributes); - } - - virtual void provideAttributeValueUpdate(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes) - throw (RTI::ObjectNotKnown, - RTI::AttributeNotKnown, - RTI::AttributeNotOwned, - RTI::FederateInternalError) - { - ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle); - if (i == _rtiAmbassador._objectInstanceMap.end()) - throw RTI::ObjectNotKnown("Reflect attributes for unknown object!"); - if (!i->second.valid()) - return; - i->second->provideAttributeValueUpdate(attributes); - } - - virtual void turnUpdatesOnForObjectInstance(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes) - throw (RTI::ObjectNotKnown, - RTI::AttributeNotOwned, - RTI::FederateInternalError) - { - ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle); - if (i == _rtiAmbassador._objectInstanceMap.end()) - throw RTI::ObjectNotKnown("Turn on attributes for unknown object!"); - if (!i->second.valid()) - return; - i->second->turnUpdatesOnForObjectInstance(attributes); - } - - virtual void turnUpdatesOffForObjectInstance(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes) - throw (RTI::ObjectNotKnown, - RTI::AttributeNotOwned, - RTI::FederateInternalError) - { - ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle); - if (i == _rtiAmbassador._objectInstanceMap.end()) - throw RTI::ObjectNotKnown("Turn off attributes for unknown object!"); - if (!i->second.valid()) - return; - i->second->turnUpdatesOffForObjectInstance(attributes); - } - - // Ownership Management - virtual void requestAttributeOwnershipAssumption(RTI::ObjectHandle objectHandle, - const RTI::AttributeHandleSet& attributes, const char* tag) - throw (RTI::ObjectNotKnown, - RTI::AttributeNotKnown, - RTI::AttributeAlreadyOwned, - RTI::AttributeNotPublished, - RTI::FederateInternalError) - { - ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle); - if (i == _rtiAmbassador._objectInstanceMap.end()) - throw RTI::ObjectNotKnown("requestAttributeOwnershipAssumption for unknown object!"); - if (!i->second.valid()) - return; - i->second->requestAttributeOwnershipAssumption(attributes, tagToData(tag)); - } - - virtual void attributeOwnershipDivestitureNotification(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes) - throw (RTI::ObjectNotKnown, - RTI::AttributeNotKnown, - RTI::AttributeNotOwned, - RTI::AttributeDivestitureWasNotRequested, - RTI::FederateInternalError) - { - ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle); - if (i == _rtiAmbassador._objectInstanceMap.end()) - throw RTI::ObjectNotKnown("attributeOwnershipDivestitureNotification for unknown object!"); - if (!i->second.valid()) - return; - i->second->attributeOwnershipDivestitureNotification(attributes); - } - - virtual void attributeOwnershipAcquisitionNotification(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes) - throw (RTI::ObjectNotKnown, - RTI::AttributeNotKnown, - RTI::AttributeAcquisitionWasNotRequested, - RTI::AttributeAlreadyOwned, - RTI::AttributeNotPublished, - RTI::FederateInternalError) - { - ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle); - if (i == _rtiAmbassador._objectInstanceMap.end()) - throw RTI::ObjectNotKnown("attributeOwnershipAcquisitionNotification for unknown object!"); - if (!i->second.valid()) - return; - i->second->attributeOwnershipAcquisitionNotification(attributes); - } - - virtual void attributeOwnershipUnavailable(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes) - throw (RTI::ObjectNotKnown, - RTI::AttributeNotKnown, - RTI::AttributeAlreadyOwned, - RTI::AttributeAcquisitionWasNotRequested, - RTI::FederateInternalError) - { - ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle); - if (i == _rtiAmbassador._objectInstanceMap.end()) - throw RTI::ObjectNotKnown("attributeOwnershipUnavailable for unknown object!"); - if (!i->second.valid()) - return; - i->second->attributeOwnershipUnavailable(attributes); - } - - virtual void requestAttributeOwnershipRelease(RTI::ObjectHandle objectHandle, - const RTI::AttributeHandleSet& attributes, const char* tag) - throw (RTI::ObjectNotKnown, - RTI::AttributeNotKnown, - RTI::AttributeNotOwned, - RTI::FederateInternalError) - { - ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle); - if (i == _rtiAmbassador._objectInstanceMap.end()) - throw RTI::ObjectNotKnown("requestAttributeOwnershipRelease for unknown object!"); - if (!i->second.valid()) - return; - i->second->requestAttributeOwnershipRelease(attributes, tagToData(tag)); - } - - virtual void confirmAttributeOwnershipAcquisitionCancellation(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes) - throw (RTI::ObjectNotKnown, - RTI::AttributeNotKnown, - RTI::AttributeAlreadyOwned, - RTI::AttributeAcquisitionWasNotCanceled, - RTI::FederateInternalError) - { - ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle); - if (i == _rtiAmbassador._objectInstanceMap.end()) - throw RTI::ObjectNotKnown("confirmAttributeOwnershipAcquisitionCancellation for unknown object!"); - if (!i->second.valid()) - return; - i->second->confirmAttributeOwnershipAcquisitionCancellation(attributes); - } - - virtual void informAttributeOwnership(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle, - RTI::FederateHandle federateHandle) - throw (RTI::ObjectNotKnown, - RTI::AttributeNotKnown, - RTI::FederateInternalError) - { - ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle); - if (i == _rtiAmbassador._objectInstanceMap.end()) - throw RTI::ObjectNotKnown("informAttributeOwnership for unknown object!"); - if (!i->second.valid()) - return; - i->second->informAttributeOwnership(attributeHandle, federateHandle); - } - - virtual void attributeIsNotOwned(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle) - throw (RTI::ObjectNotKnown, - RTI::AttributeNotKnown, - RTI::FederateInternalError) - { - ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle); - if (i == _rtiAmbassador._objectInstanceMap.end()) - throw RTI::ObjectNotKnown("attributeIsNotOwned for unknown object!"); - if (!i->second.valid()) - return; - i->second->attributeIsNotOwned(attributeHandle); - } - - virtual void attributeOwnedByRTI(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle) - throw (RTI::ObjectNotKnown, - RTI::AttributeNotKnown, - RTI::FederateInternalError) - { - ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle); - if (i == _rtiAmbassador._objectInstanceMap.end()) - throw RTI::ObjectNotKnown("attributeOwnedByRTI for unknown object!"); - if (!i->second.valid()) - return; - i->second->attributeOwnedByRTI(attributeHandle); - } - - // Time Management - virtual void timeRegulationEnabled(const RTI::FedTime& fedTime) - throw (RTI::InvalidFederationTime, - RTI::EnableTimeRegulationWasNotPending, - RTI::FederateInternalError) - { - _rtiAmbassador._timeRegulationEnabled = true; - _rtiAmbassador._federateTime = toTimeStamp(fedTime); - SG_LOG(SG_NETWORK, SG_INFO, "RTI: timeRegulationEnabled: " << _rtiAmbassador._federateTime); - } - - virtual void timeConstrainedEnabled(const RTI::FedTime& fedTime) - throw (RTI::InvalidFederationTime, - RTI::EnableTimeConstrainedWasNotPending, - RTI::FederateInternalError) - { - _rtiAmbassador._timeConstrainedEnabled = true; - _rtiAmbassador._federateTime = toTimeStamp(fedTime); - SG_LOG(SG_NETWORK, SG_INFO, "RTI: timeConstrainedEnabled: " << _rtiAmbassador._federateTime); - } - - virtual void timeAdvanceGrant(const RTI::FedTime& fedTime) - throw (RTI::InvalidFederationTime, - RTI::TimeAdvanceWasNotInProgress, - RTI::FederateInternalError) - { - _rtiAmbassador._federateTime = toTimeStamp(fedTime); - _rtiAmbassador._timeAdvancePending = false; - SG_LOG(SG_NETWORK, SG_INFO, "RTI: timeAdvanceGrant: " << _rtiAmbassador._federateTime); - } - - virtual void requestRetraction(RTI::EventRetractionHandle eventRetractionHandle) - throw (RTI::EventNotKnown, - RTI::FederateInternalError) - { - // No retraction concept yet - } - - private: - const RTIData& tagToData(const char* tag) - { - if (tag) - _cachedTag.setData(tag, std::strlen(tag) + 1); - else - _cachedTag.setData("", 1); - return _cachedTag; - } - RTIData _cachedTag; - - RTI13Ambassador& _rtiAmbassador; - }; static SGTimeStamp toTimeStamp(const RTI::FedTime& fedTime) { @@ -1052,45 +475,9 @@ private: return s; } - static std::string toStdString(const char* n) - { - if (!n) - return std::string(); - return std::string(n); - } - // The connection class RTI::RTIambassador _rtiAmbassador; - - // The class with all the callbacks. - FederateAmbassador _federateAmbassador; - - // All the sync labels we got an announcement for - std::set _pendingSyncLabels; - std::set _syncronizedSyncLabels; - - // All that calls back into user code is just queued. - // That is to make sure we do not call recursively into the RTI - typedef std::list > QueueCallbackList; - QueueCallbackList _queueCallbackList; - // All object instances that need to be called due to some event are noted here - // That is to make sure we do not call recursively into the RTI - typedef std::set > ObjectInstanceSet; - ObjectInstanceSet _objectInstancePendingCallbackList; - - // Top level information for dispatching federate object attribute updates - typedef std::map > ObjectInstanceMap; - // Map of all available objects - ObjectInstanceMap _objectInstanceMap; - - // Top level information for dispatching creation of federate objects - typedef std::map > ObjectClassMap; - ObjectClassMap _objectClassMap; - - bool _timeRegulationEnabled; - bool _timeConstrainedEnabled; - bool _timeAdvancePending; - SGTimeStamp _federateTime; + SGWeakPtr _federate; }; } // namespace simgear diff --git a/simgear/hla/RTI13Federate.cxx b/simgear/hla/RTI13Federate.cxx index a77fbaea..bb86d12f 100644 --- a/simgear/hla/RTI13Federate.cxx +++ b/simgear/hla/RTI13Federate.cxx @@ -1,4 +1,4 @@ -// Copyright (C) 2009 - 2010 Mathias Froehlich - Mathias.Froehlich@web.de +// Copyright (C) 2009 - 2011 Mathias Froehlich - Mathias.Froehlich@web.de // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Library General Public @@ -21,10 +21,570 @@ namespace simgear { -RTI13Federate::RTI13Federate(const std::list& stringList) : - _tickTimeout(10), - _ambassador(new RTI13Ambassador) +static std::string toStdString(const char* n) { + if (!n) + return std::string(); + return std::string(n); +} + +/// Just the interface class doing the callbacks into the parent class +struct RTI13Federate::FederateAmbassador : public RTI::FederateAmbassador { + FederateAmbassador() : + _timeRegulationEnabled(false), + _timeConstrainedEnabled(false), + _timeAdvancePending(false) + { + } + virtual ~FederateAmbassador() + throw (RTI::FederateInternalError) + { + } + + /// RTI federate ambassador callback functions. + virtual void synchronizationPointRegistrationSucceeded(const char* label) + throw (RTI::FederateInternalError) + { + } + + virtual void synchronizationPointRegistrationFailed(const char* label) + throw (RTI::FederateInternalError) + { + } + + virtual void announceSynchronizationPoint(const char* label, const char* tag) + throw (RTI::FederateInternalError) + { + _pendingSyncLabels.insert(toStdString(label)); + } + + virtual void federationSynchronized(const char* label) + throw (RTI::FederateInternalError) + { + std::string s = toStdString(label); + _pendingSyncLabels.erase(s); + _syncronizedSyncLabels.insert(s); + } + + virtual void initiateFederateSave(const char* label) + throw (RTI::UnableToPerformSave, + RTI::FederateInternalError) + { + } + + virtual void federationSaved() + throw (RTI::FederateInternalError) + { + } + + virtual void federationNotSaved() + throw (RTI::FederateInternalError) + { + } + + virtual void requestFederationRestoreSucceeded(const char* label) + throw (RTI::FederateInternalError) + { + } + + virtual void requestFederationRestoreFailed(const char* label, const char* reason) + throw (RTI::FederateInternalError) + { + } + + virtual void federationRestoreBegun() + throw (RTI::FederateInternalError) + { + } + + virtual void initiateFederateRestore(const char* label, RTI::FederateHandle federateHandle) + throw (RTI::SpecifiedSaveLabelDoesNotExist, + RTI::CouldNotRestore, + RTI::FederateInternalError) + { + } + + virtual void federationRestored() + throw (RTI::FederateInternalError) + { + } + + virtual void federationNotRestored() + throw (RTI::FederateInternalError) + { + } + + // Declaration Management + virtual void startRegistrationForObjectClass(RTI::ObjectClassHandle objectClassHandle) + throw (RTI::ObjectClassNotPublished, + RTI::FederateInternalError) + { + ObjectClassMap::iterator i = _objectClassMap.find(objectClassHandle); + if (i == _objectClassMap.end()) + return; + if (!i->second.valid()) + return; + i->second->startRegistration(); + } + + virtual void stopRegistrationForObjectClass(RTI::ObjectClassHandle objectClassHandle) + throw (RTI::ObjectClassNotPublished, + RTI::FederateInternalError) + { + ObjectClassMap::iterator i = _objectClassMap.find(objectClassHandle); + if (i == _objectClassMap.end()) + return; + if (!i->second.valid()) + return; + i->second->stopRegistration(); + } + + virtual void turnInteractionsOn(RTI::InteractionClassHandle interactionClassHandle) + throw (RTI::InteractionClassNotPublished, + RTI::FederateInternalError) + { + } + + virtual void turnInteractionsOff(RTI::InteractionClassHandle interactionClassHandle) + throw (RTI::InteractionClassNotPublished, + RTI::FederateInternalError) + { + } + + + // Object Management + virtual void discoverObjectInstance(RTI::ObjectHandle objectHandle, RTI::ObjectClassHandle objectClassHandle, const char* tag) + throw (RTI::CouldNotDiscover, + RTI::ObjectClassNotKnown, + RTI::FederateInternalError) + { + ObjectClassMap::iterator i = _objectClassMap.find(objectClassHandle); + if (i == _objectClassMap.end()) + throw RTI::ObjectClassNotKnown("Federate: discoverObjectInstance()!"); + if (!i->second.valid()) + return; + SGSharedPtr objectInstance = new RTI13ObjectInstance(objectHandle, 0, i->second, _rtiAmbassador.get(), false); + _objectInstanceMap[objectHandle] = objectInstance; + _queueCallbackList.push_back(new DiscoverObjectCallback(i->second, objectInstance, tagToData(tag))); + } + + virtual void reflectAttributeValues(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleValuePairSet& attributeValuePairSet, + const RTI::FedTime& fedTime, const char* tag, RTI::EventRetractionHandle eventRetractionHandle) + throw (RTI::ObjectNotKnown, + RTI::AttributeNotKnown, + RTI::FederateOwnsAttributes, + RTI::InvalidFederationTime, + RTI::FederateInternalError) + { + ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle); + if (i == _objectInstanceMap.end()) + throw RTI::ObjectNotKnown("Reflect attributes for unknown object!"); + if (!i->second.valid()) + return; + i->second->reflectAttributeValues(attributeValuePairSet, RTI13Ambassador::toTimeStamp(fedTime), tagToData(tag)); + } + + virtual void reflectAttributeValues(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleValuePairSet& attributeValuePairSet, + const char* tag) + throw (RTI::ObjectNotKnown, + RTI::AttributeNotKnown, + RTI::FederateOwnsAttributes, + RTI::FederateInternalError) + { + ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle); + if (i == _objectInstanceMap.end()) + throw RTI::ObjectNotKnown("Reflect attributes for unknown object!"); + if (!i->second.valid()) + return; + i->second->reflectAttributeValues(attributeValuePairSet, tagToData(tag)); + } + + virtual void receiveInteraction(RTI::InteractionClassHandle interactionClassHandle, const RTI::ParameterHandleValuePairSet& parameters, + const RTI::FedTime& fedTime, const char* tag, RTI::EventRetractionHandle eventRetractionHandle) + throw (RTI::InteractionClassNotKnown, + RTI::InteractionParameterNotKnown, + RTI::InvalidFederationTime, + RTI::FederateInternalError) + { + } + + virtual void receiveInteraction(RTI::InteractionClassHandle interactionClassHandle, + const RTI::ParameterHandleValuePairSet& parameters, const char* tag) + throw (RTI::InteractionClassNotKnown, + RTI::InteractionParameterNotKnown, + RTI::FederateInternalError) + { + } + + virtual void removeObjectInstance(RTI::ObjectHandle objectHandle, const RTI::FedTime& fedTime, + const char* tag, RTI::EventRetractionHandle eventRetractionHandle) + throw (RTI::ObjectNotKnown, + RTI::InvalidFederationTime, + RTI::FederateInternalError) + { + ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle); + if (i == _objectInstanceMap.end()) + throw RTI::ObjectNotKnown("Federate: removeObjectInstance()!"); + if (i->second.valid()) + _queueCallbackList.push_back(new RemoveObjectCallback(i->second, tagToData(tag))); + _objectInstanceMap.erase(i); + } + + virtual void removeObjectInstance(RTI::ObjectHandle objectHandle, const char* tag) + throw (RTI::ObjectNotKnown, + RTI::FederateInternalError) + { + ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle); + if (i == _objectInstanceMap.end()) + throw RTI::ObjectNotKnown("Federate: removeObjectInstance()!"); + if (i->second.valid()) + _queueCallbackList.push_back(new RemoveObjectCallback(i->second, tagToData(tag))); + _objectInstanceMap.erase(i); + } + + virtual void attributesInScope(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes) + throw (RTI::ObjectNotKnown, + RTI::AttributeNotKnown, + RTI::FederateInternalError) + { + ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle); + if (i == _objectInstanceMap.end()) + throw RTI::ObjectNotKnown("Attributes in scope for unknown object!"); + if (!i->second.valid()) + return; + i->second->attributesInScope(attributes); + } + + virtual void attributesOutOfScope(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes) + throw (RTI::ObjectNotKnown, + RTI::AttributeNotKnown, + RTI::FederateInternalError) + { + ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle); + if (i == _objectInstanceMap.end()) + throw RTI::ObjectNotKnown("Attributes in scope for unknown object!"); + if (!i->second.valid()) + return; + i->second->attributesOutOfScope(attributes); + } + + virtual void provideAttributeValueUpdate(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes) + throw (RTI::ObjectNotKnown, + RTI::AttributeNotKnown, + RTI::AttributeNotOwned, + RTI::FederateInternalError) + { + ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle); + if (i == _objectInstanceMap.end()) + throw RTI::ObjectNotKnown("Reflect attributes for unknown object!"); + if (!i->second.valid()) + return; + i->second->provideAttributeValueUpdate(attributes); + } + + virtual void turnUpdatesOnForObjectInstance(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes) + throw (RTI::ObjectNotKnown, + RTI::AttributeNotOwned, + RTI::FederateInternalError) + { + ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle); + if (i == _objectInstanceMap.end()) + throw RTI::ObjectNotKnown("Turn on attributes for unknown object!"); + if (!i->second.valid()) + return; + i->second->turnUpdatesOnForObjectInstance(attributes); + } + + virtual void turnUpdatesOffForObjectInstance(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes) + throw (RTI::ObjectNotKnown, + RTI::AttributeNotOwned, + RTI::FederateInternalError) + { + ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle); + if (i == _objectInstanceMap.end()) + throw RTI::ObjectNotKnown("Turn off attributes for unknown object!"); + if (!i->second.valid()) + return; + i->second->turnUpdatesOffForObjectInstance(attributes); + } + + // Ownership Management + virtual void requestAttributeOwnershipAssumption(RTI::ObjectHandle objectHandle, + const RTI::AttributeHandleSet& attributes, const char* tag) + throw (RTI::ObjectNotKnown, + RTI::AttributeNotKnown, + RTI::AttributeAlreadyOwned, + RTI::AttributeNotPublished, + RTI::FederateInternalError) + { + ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle); + if (i == _objectInstanceMap.end()) + throw RTI::ObjectNotKnown("requestAttributeOwnershipAssumption for unknown object!"); + if (!i->second.valid()) + return; + i->second->requestAttributeOwnershipAssumption(attributes, tagToData(tag)); + } + + virtual void attributeOwnershipDivestitureNotification(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes) + throw (RTI::ObjectNotKnown, + RTI::AttributeNotKnown, + RTI::AttributeNotOwned, + RTI::AttributeDivestitureWasNotRequested, + RTI::FederateInternalError) + { + ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle); + if (i == _objectInstanceMap.end()) + throw RTI::ObjectNotKnown("attributeOwnershipDivestitureNotification for unknown object!"); + if (!i->second.valid()) + return; + i->second->attributeOwnershipDivestitureNotification(attributes); + } + + virtual void attributeOwnershipAcquisitionNotification(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes) + throw (RTI::ObjectNotKnown, + RTI::AttributeNotKnown, + RTI::AttributeAcquisitionWasNotRequested, + RTI::AttributeAlreadyOwned, + RTI::AttributeNotPublished, + RTI::FederateInternalError) + { + ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle); + if (i == _objectInstanceMap.end()) + throw RTI::ObjectNotKnown("attributeOwnershipAcquisitionNotification for unknown object!"); + if (!i->second.valid()) + return; + i->second->attributeOwnershipAcquisitionNotification(attributes); + } + + virtual void attributeOwnershipUnavailable(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes) + throw (RTI::ObjectNotKnown, + RTI::AttributeNotKnown, + RTI::AttributeAlreadyOwned, + RTI::AttributeAcquisitionWasNotRequested, + RTI::FederateInternalError) + { + ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle); + if (i == _objectInstanceMap.end()) + throw RTI::ObjectNotKnown("attributeOwnershipUnavailable for unknown object!"); + if (!i->second.valid()) + return; + i->second->attributeOwnershipUnavailable(attributes); + } + + virtual void requestAttributeOwnershipRelease(RTI::ObjectHandle objectHandle, + const RTI::AttributeHandleSet& attributes, const char* tag) + throw (RTI::ObjectNotKnown, + RTI::AttributeNotKnown, + RTI::AttributeNotOwned, + RTI::FederateInternalError) + { + ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle); + if (i == _objectInstanceMap.end()) + throw RTI::ObjectNotKnown("requestAttributeOwnershipRelease for unknown object!"); + if (!i->second.valid()) + return; + i->second->requestAttributeOwnershipRelease(attributes, tagToData(tag)); + } + + virtual void confirmAttributeOwnershipAcquisitionCancellation(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes) + throw (RTI::ObjectNotKnown, + RTI::AttributeNotKnown, + RTI::AttributeAlreadyOwned, + RTI::AttributeAcquisitionWasNotCanceled, + RTI::FederateInternalError) + { + ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle); + if (i == _objectInstanceMap.end()) + throw RTI::ObjectNotKnown("confirmAttributeOwnershipAcquisitionCancellation for unknown object!"); + if (!i->second.valid()) + return; + i->second->confirmAttributeOwnershipAcquisitionCancellation(attributes); + } + + virtual void informAttributeOwnership(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle, + RTI::FederateHandle federateHandle) + throw (RTI::ObjectNotKnown, + RTI::AttributeNotKnown, + RTI::FederateInternalError) + { + ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle); + if (i == _objectInstanceMap.end()) + throw RTI::ObjectNotKnown("informAttributeOwnership for unknown object!"); + if (!i->second.valid()) + return; + i->second->informAttributeOwnership(attributeHandle, federateHandle); + } + + virtual void attributeIsNotOwned(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle) + throw (RTI::ObjectNotKnown, + RTI::AttributeNotKnown, + RTI::FederateInternalError) + { + ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle); + if (i == _objectInstanceMap.end()) + throw RTI::ObjectNotKnown("attributeIsNotOwned for unknown object!"); + if (!i->second.valid()) + return; + i->second->attributeIsNotOwned(attributeHandle); + } + + virtual void attributeOwnedByRTI(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle) + throw (RTI::ObjectNotKnown, + RTI::AttributeNotKnown, + RTI::FederateInternalError) + { + ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle); + if (i == _objectInstanceMap.end()) + throw RTI::ObjectNotKnown("attributeOwnedByRTI for unknown object!"); + if (!i->second.valid()) + return; + i->second->attributeOwnedByRTI(attributeHandle); + } + + // Time Management + virtual void timeRegulationEnabled(const RTI::FedTime& fedTime) + throw (RTI::InvalidFederationTime, + RTI::EnableTimeRegulationWasNotPending, + RTI::FederateInternalError) + { + _timeRegulationEnabled = true; + _federateTime = RTI13Ambassador::toTimeStamp(fedTime); + SG_LOG(SG_NETWORK, SG_INFO, "RTI: timeRegulationEnabled: " << _federateTime); + } + + virtual void timeConstrainedEnabled(const RTI::FedTime& fedTime) + throw (RTI::InvalidFederationTime, + RTI::EnableTimeConstrainedWasNotPending, + RTI::FederateInternalError) + { + _timeConstrainedEnabled = true; + _federateTime = RTI13Ambassador::toTimeStamp(fedTime); + SG_LOG(SG_NETWORK, SG_INFO, "RTI: timeConstrainedEnabled: " << _federateTime); + } + + virtual void timeAdvanceGrant(const RTI::FedTime& fedTime) + throw (RTI::InvalidFederationTime, + RTI::TimeAdvanceWasNotInProgress, + RTI::FederateInternalError) + { + _federateTime = RTI13Ambassador::toTimeStamp(fedTime); + _timeAdvancePending = false; + SG_LOG(SG_NETWORK, SG_INFO, "RTI: timeAdvanceGrant: " << _federateTime); + } + + virtual void requestRetraction(RTI::EventRetractionHandle eventRetractionHandle) + throw (RTI::EventNotKnown, + RTI::FederateInternalError) + { + // No retraction concept yet + } + + // processes the queues that filled up during the past + void processQueues() + { + while (!_queueCallbackList.empty()) { + (*_queueCallbackList.front())(); + _queueCallbackList.pop_front(); + } + } + + bool getFederationSynchronizationPointAnnounced(const std::string& label) + { return _pendingSyncLabels.find(label) != _pendingSyncLabels.end(); } + bool getFederationSynchronized(const std::string& label) + { + std::set::iterator i = _syncronizedSyncLabels.find(label); + if (i == _syncronizedSyncLabels.end()) + return false; + _syncronizedSyncLabels.erase(i); + return true; + } + + /// Generic callback to execute some notification on objects in a way that they are not prone to + /// ConcurrentAccess exceptions. + class QueueCallback : public SGReferenced { + public: + virtual ~QueueCallback() {} + virtual void operator()() = 0; + }; + + class DiscoverObjectCallback : public QueueCallback { + public: + DiscoverObjectCallback(SGSharedPtr objectClass, SGSharedPtr objectInstance, const RTIData& tag) : + _objectClass(objectClass), + _objectInstance(objectInstance), + _tag(tag) + { } + virtual void operator()() + { + _objectClass->discoverInstance(_objectInstance.get(), _tag); + _objectInstance->requestObjectAttributeValueUpdate(); + } + private: + SGSharedPtr _objectClass; + SGSharedPtr _objectInstance; + RTIData _tag; + }; + class RemoveObjectCallback : public QueueCallback { + public: + RemoveObjectCallback(SGSharedPtr objectInstance, const RTIData& tag) : + _objectInstance(objectInstance), + _tag(tag) + { } + virtual void operator()() + { + _objectInstance->removeInstance(_tag); + } + private: + SGSharedPtr _objectInstance; + RTIData _tag; + }; + + // The rtiambassador to issue requests + SGSharedPtr _rtiAmbassador; + + // All the sync labels we got an announcement for + std::set _pendingSyncLabels; + std::set _syncronizedSyncLabels; + + // All that calls back into user code is just queued. + // That is to make sure we do not call recursively into the RTI + typedef std::list > QueueCallbackList; + QueueCallbackList _queueCallbackList; + + // Top level information for dispatching federate object attribute updates + typedef std::map > ObjectInstanceMap; + // Map of all available objects + ObjectInstanceMap _objectInstanceMap; + + // Top level information for dispatching creation of federate objects + typedef std::map > ObjectClassMap; + ObjectClassMap _objectClassMap; + + bool _timeRegulationEnabled; + bool _timeConstrainedEnabled; + bool _timeAdvancePending; + SGTimeStamp _federateTime; + +private: + const RTIData& tagToData(const char* tag) + { + if (tag) + _cachedTag.setData(tag, std::strlen(tag) + 1); + else + _cachedTag.setData("", 1); + return _cachedTag; + } + RTIData _cachedTag; +}; + +RTI13Federate::RTI13Federate(const std::list& stringList) : + _joined(false), + _tickTimeout(10), + _ambassador(new RTI13Ambassador), + _federateAmbassador(new FederateAmbassador) +{ + _ambassador->_federate = this; + _federateAmbassador->_rtiAmbassador = _ambassador; if (stringList.empty()) { SG_LOG(SG_NETWORK, SG_WARN, "RTI: Ignoring non empty connect arguments while connecting to an RTI13 federation!"); } @@ -32,84 +592,86 @@ RTI13Federate::RTI13Federate(const std::list& stringList) : RTI13Federate::~RTI13Federate() { + if (_joined) + _ambassador->resignFederationExecution(); + delete _federateAmbassador; } -bool +RTI13Federate::FederationManagementResult RTI13Federate::createFederationExecution(const std::string& federationName, const std::string& objectModel) { try { _ambassador->createFederationExecution(federationName, objectModel); - return true; + return FederationManagementSuccess; } catch (RTI::FederationExecutionAlreadyExists& e) { - return true; + return FederationManagementFail; } catch (RTI::CouldNotOpenFED& e) { SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not create federation execution: " << e._name << " " << e._reason); - return false; + return FederationManagementFatal; } catch (RTI::ErrorReadingFED& e) { SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not create federation execution: " << e._name << " " << e._reason); - return false; + return FederationManagementFatal; } catch (RTI::ConcurrentAccessAttempted& e) { SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not create federation execution: " << e._name << " " << e._reason); - return false; + return FederationManagementFatal; } catch (RTI::RTIinternalError& e) { SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not create federation execution: " << e._name << " " << e._reason); - return false; + return FederationManagementFatal; } } -bool +RTI13Federate::FederationManagementResult RTI13Federate::destroyFederationExecution(const std::string& federation) { try { _ambassador->destroyFederationExecution(federation); - return true; + return FederationManagementSuccess; } catch (RTI::FederatesCurrentlyJoined& e) { - return true; + return FederationManagementFail; } catch (RTI::FederationExecutionDoesNotExist& e) { - return true; + return FederationManagementFail; } catch (RTI::ConcurrentAccessAttempted& e) { SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not destroy federation execution: " << e._name << " " << e._reason); - return false; + return FederationManagementFatal; } catch (RTI::RTIinternalError& e) { SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not destroy federation execution: " << e._name << " " << e._reason); - return false; + return FederationManagementFatal; } } -bool +RTI13Federate::FederationManagementResult RTI13Federate::join(const std::string& federateType, const std::string& federationName) { try { - _federateHandle = _ambassador->joinFederationExecution(federateType, federationName); + _federateHandle = _ambassador->joinFederationExecution(federateType, federationName, _federateAmbassador); SG_LOG(SG_NETWORK, SG_INFO, "RTI: Joined federation \"" << federationName << "\" as \"" << federateType << "\""); - setFederateType(federateType); - setFederationName(federationName); - return true; + _joined = true; + return FederationManagementSuccess; } catch (RTI::FederateAlreadyExecutionMember& e) { SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason); - return false; + return FederationManagementFatal; } catch (RTI::FederationExecutionDoesNotExist& e) { SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason); - return false; + return FederationManagementFail; } catch (RTI::CouldNotOpenFED& e) { SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason); - return false; + return FederationManagementFatal; } catch (RTI::ErrorReadingFED& e) { SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason); - return false; + return FederationManagementFatal; } catch (RTI::ConcurrentAccessAttempted& e) { SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason); - return false; + return FederationManagementFatal; } catch (RTI::SaveInProgress& e) { SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason); - return false; + return FederationManagementFatal; } catch (RTI::RestoreInProgress& e) { SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason); - return false; + return FederationManagementFatal; } catch (RTI::RTIinternalError& e) { SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason); - return false; + return FederationManagementFatal; } } @@ -119,6 +681,7 @@ RTI13Federate::resign() try { _ambassador->resignFederationExecution(); SG_LOG(SG_NETWORK, SG_INFO, "RTI: Resigned from federation."); + _joined = false; _federateHandle = -1; return true; } catch (RTI::FederateOwnsAttributes& e) { @@ -167,9 +730,9 @@ RTI13Federate::registerFederationSynchronizationPoint(const std::string& label, bool RTI13Federate::waitForFederationSynchronizationPointAnnounced(const std::string& label) { - while (!_ambassador->getFederationSynchronizationPointAnnounced(label)) { + while (!_federateAmbassador->getFederationSynchronizationPointAnnounced(label)) { _ambassador->tick(_tickTimeout, 0); - _ambassador->processQueues(); + _federateAmbassador->processQueues(); } return true; } @@ -205,9 +768,9 @@ RTI13Federate::synchronizationPointAchieved(const std::string& label) bool RTI13Federate::waitForFederationSynchronized(const std::string& label) { - while (!_ambassador->getFederationSynchronized(label)) { + while (!_federateAmbassador->getFederationSynchronized(label)) { _ambassador->tick(_tickTimeout, 0); - _ambassador->processQueues(); + _federateAmbassador->processQueues(); } return true; } @@ -220,7 +783,7 @@ RTI13Federate::enableTimeConstrained() return false; } - if (_ambassador->getTimeConstrainedEnabled()) { + if (_federateAmbassador->_timeConstrainedEnabled) { SG_LOG(SG_NETWORK, SG_WARN, "RTI: Time constrained is already enabled."); return false; } @@ -253,9 +816,9 @@ RTI13Federate::enableTimeConstrained() return false; } - while (!_ambassador->getTimeConstrainedEnabled()) { + while (!_federateAmbassador->_timeConstrainedEnabled) { _ambassador->tick(_tickTimeout, 0); - _ambassador->processQueues(); + _federateAmbassador->processQueues(); } return true; @@ -269,13 +832,14 @@ RTI13Federate::disableTimeConstrained() return false; } - if (!_ambassador->getTimeConstrainedEnabled()) { + if (!_federateAmbassador->_timeConstrainedEnabled) { SG_LOG(SG_NETWORK, SG_WARN, "RTI: Time constrained is not enabled."); return false; } try { _ambassador->disableTimeConstrained(); + _federateAmbassador->_timeConstrainedEnabled = false; } catch (RTI::TimeConstrainedWasNotEnabled& e) { SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason); return false; @@ -307,13 +871,13 @@ RTI13Federate::enableTimeRegulation(const SGTimeStamp& lookahead) return false; } - if (_ambassador->getTimeRegulationEnabled()) { + if (_federateAmbassador->_timeRegulationEnabled) { SG_LOG(SG_NETWORK, SG_WARN, "RTI: Time regulation already enabled."); return false; } try { - _ambassador->enableTimeRegulation(SGTimeStamp(), lookahead); + _ambassador->enableTimeRegulation(lookahead); } catch (RTI::TimeRegulationAlreadyEnabled& e) { SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason); return false; @@ -346,9 +910,9 @@ RTI13Federate::enableTimeRegulation(const SGTimeStamp& lookahead) return false; } - while (!_ambassador->getTimeRegulationEnabled()) { + while (!_federateAmbassador->_timeRegulationEnabled) { _ambassador->tick(_tickTimeout, 0); - _ambassador->processQueues(); + _federateAmbassador->processQueues(); } return true; @@ -362,13 +926,14 @@ RTI13Federate::disableTimeRegulation() return false; } - if (!_ambassador->getTimeRegulationEnabled()) { + if (!_federateAmbassador->_timeRegulationEnabled) { SG_LOG(SG_NETWORK, SG_WARN, "RTI: Time regulation is not enabled."); return false; } try { _ambassador->disableTimeRegulation(); + _federateAmbassador->_timeRegulationEnabled = false; } catch (RTI::TimeRegulationWasNotEnabled& e) { SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason); return false; @@ -400,7 +965,7 @@ RTI13Federate::timeAdvanceRequestBy(const SGTimeStamp& dt) return false; } - SGTimeStamp fedTime = _ambassador->getCurrentLogicalTime() + dt; + SGTimeStamp fedTime = _federateAmbassador->_federateTime + dt; return timeAdvanceRequest(fedTime); } @@ -414,6 +979,7 @@ RTI13Federate::timeAdvanceRequest(const SGTimeStamp& fedTime) try { _ambassador->timeAdvanceRequest(fedTime); + _federateAmbassador->_timeAdvancePending = true; } catch (RTI::InvalidFederationTime& e) { SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason); return false; @@ -446,9 +1012,9 @@ RTI13Federate::timeAdvanceRequest(const SGTimeStamp& fedTime) return false; } - while (_ambassador->getTimeAdvancePending()) { + while (_federateAmbassador->_timeAdvancePending) { _ambassador->tick(_tickTimeout, 0); - _ambassador->processQueues(); + _federateAmbassador->processQueues(); } return true; @@ -543,11 +1109,69 @@ RTI13Federate::queryLookahead(SGTimeStamp& timeStamp) return true; } +bool +RTI13Federate::queryGALT(SGTimeStamp& timeStamp) +{ + if (!_ambassador.valid()) { + SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query GALT."); + return false; + } + + try { + return _ambassador->queryGALT(timeStamp); + } catch (RTI::FederateNotExecutionMember& e) { + SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query GALT: " << e._name << " " << e._reason); + return false; + } catch (RTI::ConcurrentAccessAttempted& e) { + SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query GALT: " << e._name << " " << e._reason); + return false; + } catch (RTI::SaveInProgress& e) { + SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query GALT: " << e._name << " " << e._reason); + return false; + } catch (RTI::RestoreInProgress& e) { + SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query GALT: " << e._name << " " << e._reason); + return false; + } catch (RTI::RTIinternalError& e) { + SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query GALT: " << e._name << " " << e._reason); + return false; + } + return true; +} + +bool +RTI13Federate::queryLITS(SGTimeStamp& timeStamp) +{ + if (!_ambassador.valid()) { + SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query LITS."); + return false; + } + + try { + return _ambassador->queryLITS(timeStamp); + } catch (RTI::FederateNotExecutionMember& e) { + SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query LITS: " << e._name << " " << e._reason); + return false; + } catch (RTI::ConcurrentAccessAttempted& e) { + SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query LITS: " << e._name << " " << e._reason); + return false; + } catch (RTI::SaveInProgress& e) { + SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query LITS: " << e._name << " " << e._reason); + return false; + } catch (RTI::RestoreInProgress& e) { + SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query LITS: " << e._name << " " << e._reason); + return false; + } catch (RTI::RTIinternalError& e) { + SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query LITS: " << e._name << " " << e._reason); + return false; + } + return true; +} + bool RTI13Federate::tick() { bool result = _ambassador->tick(); - _ambassador->processQueues(); + _federateAmbassador->processQueues(); return result; } @@ -555,7 +1179,7 @@ bool RTI13Federate::tick(const double& minimum, const double& maximum) { bool result = _ambassador->tick(minimum, maximum); - _ambassador->processQueues(); + _federateAmbassador->processQueues(); return result; } @@ -563,7 +1187,16 @@ RTI13ObjectClass* RTI13Federate::createObjectClass(const std::string& objectClassName, HLAObjectClass* hlaObjectClass) { try { - return _ambassador->createObjectClass(objectClassName, hlaObjectClass); + RTI::ObjectClassHandle objectClassHandle; + objectClassHandle = _ambassador->getObjectClassHandle(objectClassName); + if (_federateAmbassador->_objectClassMap.find(objectClassHandle) != _federateAmbassador->_objectClassMap.end()) { + SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not create object class, object class already exists!"); + return 0; + } + RTI13ObjectClass* rtiObjectClass; + rtiObjectClass = new RTI13ObjectClass(hlaObjectClass, objectClassHandle, _ambassador.get()); + _federateAmbassador->_objectClassMap[objectClassHandle] = rtiObjectClass; + return rtiObjectClass; } catch (RTI::NameNotFound& e) { SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: " << e._name << " " << e._reason); return 0; @@ -583,7 +1216,14 @@ RTI13ObjectInstance* RTI13Federate::getObjectInstance(const std::string& objectInstanceName) { try { - return _ambassador->getObjectInstance(objectInstanceName); + RTI::ObjectHandle objectHandle; + objectHandle = _ambassador->getObjectInstanceHandle(objectInstanceName); + FederateAmbassador::ObjectInstanceMap::iterator i = _federateAmbassador->_objectInstanceMap.find(objectHandle); + if (i == _federateAmbassador->_objectInstanceMap.end()) { + SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: ObjectInstance not found."); + return 0; + } + return i->second; } catch (RTI::ObjectNotKnown& e) { SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: " << e._name << " " << e._reason); return 0; @@ -599,4 +1239,10 @@ RTI13Federate::getObjectInstance(const std::string& objectInstanceName) } } +void +RTI13Federate::insertObjectInstance(RTI13ObjectInstance* objectInstance) +{ + _federateAmbassador->_objectInstanceMap[objectInstance->getHandle()] = objectInstance; +} + } diff --git a/simgear/hla/RTI13Federate.hxx b/simgear/hla/RTI13Federate.hxx index 839e7d50..0a8cee4d 100644 --- a/simgear/hla/RTI13Federate.hxx +++ b/simgear/hla/RTI13Federate.hxx @@ -1,4 +1,4 @@ -// Copyright (C) 2009 - 2010 Mathias Froehlich - Mathias.Froehlich@web.de +// Copyright (C) 2009 - 2011 Mathias Froehlich - Mathias.Froehlich@web.de // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Library General Public @@ -37,11 +37,13 @@ public: RTI13Federate(const std::list& stringList); virtual ~RTI13Federate(); - virtual bool createFederationExecution(const std::string& federation, const std::string& objectModel); - virtual bool destroyFederationExecution(const std::string& federation); + /// Create a federation execution + /// Semantically this methods should be static, + virtual FederationManagementResult createFederationExecution(const std::string& federation, const std::string& objectModel); + virtual FederationManagementResult destroyFederationExecution(const std::string& federation); /// Join with federateName the federation execution federation - virtual bool join(const std::string& federateType, const std::string& federation); + virtual FederationManagementResult join(const std::string& federateType, const std::string& federation); virtual bool resign(); /// Synchronization Point handling @@ -64,6 +66,9 @@ public: virtual bool modifyLookahead(const SGTimeStamp& timeStamp); virtual bool queryLookahead(SGTimeStamp& timeStamp); + virtual bool queryGALT(SGTimeStamp& timeStamp); + virtual bool queryLITS(SGTimeStamp& timeStamp); + /// Process messages virtual bool tick(); virtual bool tick(const double& minimum, const double& maximum); @@ -71,6 +76,7 @@ public: virtual RTI13ObjectClass* createObjectClass(const std::string& name, HLAObjectClass* hlaObjectClass); virtual RTI13ObjectInstance* getObjectInstance(const std::string& name); + void insertObjectInstance(RTI13ObjectInstance* objectInstance); private: RTI13Federate(const RTI13Federate&); @@ -78,6 +84,7 @@ private: /// The federate handle RTI::FederateHandle _federateHandle; + bool _joined; /// The timeout for the single callback tick function in /// syncronous operations that need to wait for a callback @@ -85,6 +92,10 @@ private: /// RTI connection SGSharedPtr _ambassador; + + /// Callbacks from the rti are handled here. + struct FederateAmbassador; + FederateAmbassador* _federateAmbassador; }; } diff --git a/simgear/hla/RTI13ObjectClass.cxx b/simgear/hla/RTI13ObjectClass.cxx index e2ccd497..fcc41682 100644 --- a/simgear/hla/RTI13ObjectClass.cxx +++ b/simgear/hla/RTI13ObjectClass.cxx @@ -37,12 +37,11 @@ RTI13ObjectClass::~RTI13ObjectClass() std::string RTI13ObjectClass::getName() const { - SGSharedPtr ambassador = _ambassador.lock(); - if (!ambassador.valid()) { + if (!_ambassador.valid()) { SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero."); return std::string(); } - return ambassador->getObjectClassName(_handle); + return _ambassador->getObjectClassName(_handle); } unsigned @@ -54,14 +53,13 @@ RTI13ObjectClass::getNumAttributes() const unsigned RTI13ObjectClass::getAttributeIndex(const std::string& name) const { - SGSharedPtr ambassador = _ambassador.lock(); - if (!ambassador.valid()) { + if (!_ambassador.valid()) { SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero."); return ~0u; } try { - RTI::AttributeHandle attributeHandle = ambassador->getAttributeHandle(name, _handle); + RTI::AttributeHandle attributeHandle = _ambassador->getAttributeHandle(name, _handle); AttributeHandleIndexMap::const_iterator i = _attributeHandleIndexMap.find(attributeHandle); if (i != _attributeHandleIndexMap.end()) @@ -93,14 +91,13 @@ RTI13ObjectClass::getAttributeIndex(const std::string& name) const unsigned RTI13ObjectClass::getOrCreateAttributeIndex(const std::string& name) { - SGSharedPtr ambassador = _ambassador.lock(); - if (!ambassador.valid()) { + if (!_ambassador.valid()) { SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero."); return ~0u; } try { - RTI::AttributeHandle attributeHandle = ambassador->getAttributeHandle(name, _handle); + RTI::AttributeHandle attributeHandle = _ambassador->getAttributeHandle(name, _handle); AttributeHandleIndexMap::const_iterator i = _attributeHandleIndexMap.find(attributeHandle); if (i != _attributeHandleIndexMap.end()) @@ -169,8 +166,7 @@ RTI13ObjectClass::getOrCreateAttributeIndex(const std::string& name) bool RTI13ObjectClass::publish(const std::set& indexSet) { - SGSharedPtr ambassador = _ambassador.lock(); - if (!ambassador.valid()) { + if (!_ambassador.valid()) { SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero."); return false; } @@ -185,7 +181,7 @@ RTI13ObjectClass::publish(const std::set& indexSet) attributeHandleSet->add(_attributeHandleVector[*i]); } - ambassador->publishObjectClass(_handle, *attributeHandleSet); + _ambassador->publishObjectClass(_handle, *attributeHandleSet); for (unsigned i = 0; i < getNumAttributes(); ++i) { _attributeDataVector[i]._published = true; @@ -225,14 +221,13 @@ RTI13ObjectClass::publish(const std::set& indexSet) bool RTI13ObjectClass::unpublish() { - SGSharedPtr ambassador = _ambassador.lock(); - if (!ambassador.valid()) { + if (!_ambassador.valid()) { SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero."); return false; } try { - ambassador->unpublishObjectClass(_handle); + _ambassador->unpublishObjectClass(_handle); for (unsigned i = 0; i < getNumAttributes(); ++i) { _attributeDataVector[i]._published = false; @@ -272,8 +267,7 @@ RTI13ObjectClass::unpublish() bool RTI13ObjectClass::subscribe(const std::set& indexSet, bool active) { - SGSharedPtr ambassador = _ambassador.lock(); - if (!ambassador.valid()) { + if (!_ambassador.valid()) { SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero."); return false; } @@ -289,7 +283,7 @@ RTI13ObjectClass::subscribe(const std::set& indexSet, bool active) attributeHandleSet->add(_attributeHandleVector[*i]); } - ambassador->subscribeObjectClassAttributes(_handle, *attributeHandleSet, active); + _ambassador->subscribeObjectClassAttributes(_handle, *attributeHandleSet, active); for (unsigned i = 0; i < getNumAttributes(); ++i) { _attributeDataVector[i]._subscribed = true; @@ -326,14 +320,13 @@ RTI13ObjectClass::subscribe(const std::set& indexSet, bool active) bool RTI13ObjectClass::unsubscribe() { - SGSharedPtr ambassador = _ambassador.lock(); - if (!ambassador.valid()) { + if (!_ambassador.valid()) { SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero."); return 0; } try { - ambassador->unsubscribeObjectClass(_handle); + _ambassador->unsubscribeObjectClass(_handle); for (unsigned i = 0; i < getNumAttributes(); ++i) { _attributeDataVector[i]._subscribed = false; @@ -370,14 +363,22 @@ RTI13ObjectClass::unsubscribe() RTIObjectInstance* RTI13ObjectClass::registerObjectInstance(HLAObjectInstance* hlaObjectInstance) { - SGSharedPtr ambassador = _ambassador.lock(); - if (!ambassador.valid()) { + if (!_ambassador.valid()) { SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero."); return 0; } + SGSharedPtr federate = _ambassador->_federate.lock(); + if (!federate.valid()) { + SG_LOG(SG_NETWORK, SG_WARN, "Error: Federate is zero."); + return 0; + } + try { - return ambassador->registerObjectInstance(this, hlaObjectInstance); + RTI::ObjectHandle objectHandle = _ambassador->registerObjectInstance(getHandle()); + RTI13ObjectInstance* objectInstance = new RTI13ObjectInstance(objectHandle, hlaObjectInstance, this, _ambassador.get(), true); + federate->insertObjectInstance(objectInstance); + return objectInstance; } catch (RTI::ObjectClassNotDefined& e) { SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not register object instance: " << e._name << " " << e._reason); return 0; diff --git a/simgear/hla/RTI13ObjectClass.hxx b/simgear/hla/RTI13ObjectClass.hxx index e8c25cd0..c4949ca9 100644 --- a/simgear/hla/RTI13ObjectClass.hxx +++ b/simgear/hla/RTI13ObjectClass.hxx @@ -73,7 +73,7 @@ public: private: RTI::ObjectClassHandle _handle; - SGWeakPtr _ambassador; + SGSharedPtr _ambassador; typedef std::map AttributeHandleIndexMap; AttributeHandleIndexMap _attributeHandleIndexMap; diff --git a/simgear/hla/RTI13ObjectInstance.cxx b/simgear/hla/RTI13ObjectInstance.cxx index 87f6a42d..723f9b17 100644 --- a/simgear/hla/RTI13ObjectInstance.cxx +++ b/simgear/hla/RTI13ObjectInstance.cxx @@ -50,14 +50,13 @@ RTI13ObjectInstance::get13ObjectClass() const std::string RTI13ObjectInstance::getName() const { - SGSharedPtr ambassador = _ambassador.lock(); - if (!ambassador.valid()) { + if (!_ambassador.valid()) { SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero."); return std::string(); } try { - return ambassador->getObjectInstanceName(_handle); + return _ambassador->getObjectInstanceName(_handle); } catch (RTI::ObjectNotKnown& e) { SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object name: " << e._name << " " << e._reason); return std::string(); @@ -77,28 +76,21 @@ RTI13ObjectInstance::getName() const } void -RTI13ObjectInstance::addToRequestQueue() +RTI13ObjectInstance::deleteObjectInstance(const RTIData& tag) { - SGSharedPtr ambassador = _ambassador.lock(); - if (!ambassador.valid()) { + if (!_ambassador.valid()) { SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero."); return; } - ambassador->addObjectInstanceForCallback(this); -} - -void -RTI13ObjectInstance::deleteObjectInstance(const RTIData& tag) -{ - SGSharedPtr ambassador = _ambassador.lock(); - if (!ambassador.valid()) { - SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero."); + SGSharedPtr federate = _ambassador->_federate.lock(); + if (!federate.valid()) { + SG_LOG(SG_NETWORK, SG_WARN, "Error: Federate is zero."); return; } try { - ambassador->deleteObjectInstance(_handle, tag); + _ambassador->deleteObjectInstance(_handle, tag); } catch (RTI::ObjectNotKnown& e) { SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not delete object instance: " << e._name << " " << e._reason); } catch (RTI::DeletePrivilegeNotHeld& e) { @@ -119,14 +111,19 @@ RTI13ObjectInstance::deleteObjectInstance(const RTIData& tag) void RTI13ObjectInstance::deleteObjectInstance(const SGTimeStamp& timeStamp, const RTIData& tag) { - SGSharedPtr ambassador = _ambassador.lock(); - if (!ambassador.valid()) { + if (!_ambassador.valid()) { SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero."); return; } + SGSharedPtr federate = _ambassador->_federate.lock(); + if (!federate.valid()) { + SG_LOG(SG_NETWORK, SG_WARN, "Error: Federate is zero."); + return; + } + try { - ambassador->deleteObjectInstance(_handle, timeStamp, tag); + _ambassador->deleteObjectInstance(_handle, timeStamp, tag); } catch (RTI::ObjectNotKnown& e) { SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not delete object instance: " << e._name << " " << e._reason); } catch (RTI::DeletePrivilegeNotHeld& e) { @@ -149,14 +146,19 @@ RTI13ObjectInstance::deleteObjectInstance(const SGTimeStamp& timeStamp, const RT void RTI13ObjectInstance::localDeleteObjectInstance() { - SGSharedPtr ambassador = _ambassador.lock(); - if (!ambassador.valid()) { + if (!_ambassador.valid()) { SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero."); return; } + SGSharedPtr federate = _ambassador->_federate.lock(); + if (!federate.valid()) { + SG_LOG(SG_NETWORK, SG_WARN, "Error: Federate is zero."); + return; + } + try { - ambassador->localDeleteObjectInstance(_handle); + _ambassador->localDeleteObjectInstance(_handle); } catch (RTI::ObjectNotKnown& e) { SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not delete object instance: " << e._name << " " << e._reason); } catch (RTI::FederateOwnsAttributes& e) { @@ -221,8 +223,7 @@ RTI13ObjectInstance::reflectAttributeValues(const RTI::AttributeHandleValuePairS void RTI13ObjectInstance::requestObjectAttributeValueUpdate() { - SGSharedPtr ambassador = _ambassador.lock(); - if (!ambassador.valid()) { + if (!_ambassador.valid()) { SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero."); return; } @@ -238,7 +239,7 @@ RTI13ObjectInstance::requestObjectAttributeValueUpdate() if (!attributeHandleSet->size()) return; - ambassador->requestObjectAttributeValueUpdate(_handle, *attributeHandleSet); + _ambassador->requestObjectAttributeValueUpdate(_handle, *attributeHandleSet); for (unsigned i = 0; i < numAttributes; ++i) setRequestAttributeUpdate(i, false); @@ -285,8 +286,7 @@ RTI13ObjectInstance::provideAttributeValueUpdate(const RTI::AttributeHandleSet& void RTI13ObjectInstance::updateAttributeValues(const RTIData& tag) { - SGSharedPtr ambassador = _ambassador.lock(); - if (!ambassador.valid()) { + if (!_ambassador.valid()) { SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero."); return; } @@ -312,7 +312,7 @@ RTI13ObjectInstance::updateAttributeValues(const RTIData& tag) if (!_attributeValuePairSet->size()) return; - ambassador->updateAttributeValues(_handle, *_attributeValuePairSet, tag); + _ambassador->updateAttributeValues(_handle, *_attributeValuePairSet, tag); for (unsigned i = 0; i < numAttributes; ++i) { setAttributeUpdated(i); @@ -343,8 +343,7 @@ RTI13ObjectInstance::updateAttributeValues(const RTIData& tag) void RTI13ObjectInstance::updateAttributeValues(const SGTimeStamp& timeStamp, const RTIData& tag) { - SGSharedPtr ambassador = _ambassador.lock(); - if (!ambassador.valid()) { + if (!_ambassador.valid()) { SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero."); return; } @@ -370,7 +369,7 @@ RTI13ObjectInstance::updateAttributeValues(const SGTimeStamp& timeStamp, const R if (!_attributeValuePairSet->size()) return; - ambassador->updateAttributeValues(_handle, *_attributeValuePairSet, timeStamp, tag); + _ambassador->updateAttributeValues(_handle, *_attributeValuePairSet, timeStamp, tag); for (unsigned i = 0; i < numAttributes; ++i) { setAttributeUpdated(i); diff --git a/simgear/hla/RTI13ObjectInstance.hxx b/simgear/hla/RTI13ObjectInstance.hxx index ed73aa09..654bff92 100644 --- a/simgear/hla/RTI13ObjectInstance.hxx +++ b/simgear/hla/RTI13ObjectInstance.hxx @@ -61,8 +61,6 @@ public: virtual std::string getName() const; - virtual void addToRequestQueue(); - virtual void deleteObjectInstance(const RTIData& tag); virtual void deleteObjectInstance(const SGTimeStamp& timeStamp, const RTIData& tag); virtual void localDeleteObjectInstance(); @@ -95,7 +93,7 @@ public: private: RTI::ObjectHandle _handle; SGSharedPtr _objectClass; - SGWeakPtr _ambassador; + SGSharedPtr _ambassador; // cached storage for updates std::auto_ptr _attributeValuePairSet; diff --git a/simgear/hla/RTIFederate.hxx b/simgear/hla/RTIFederate.hxx index c997704f..b7aa8854 100644 --- a/simgear/hla/RTIFederate.hxx +++ b/simgear/hla/RTIFederate.hxx @@ -32,21 +32,19 @@ public: RTIFederate(); virtual ~RTIFederate(); - /// Get the name of the joined federate/federation - const std::string& getFederateType() const - { return _federateType; } - const std::string& getFederationName() const - { return _federationName; } - /// Create a federation execution /// Semantically this methods should be static, - /// but the nonstatic case could reuse the connection to the server - /// FIXME: cannot determine from the return value if we created the execution - virtual bool createFederationExecution(const std::string& federation, const std::string& objectModel) = 0; - virtual bool destroyFederationExecution(const std::string& federation) = 0; + enum FederationManagementResult { + FederationManagementSuccess, + FederationManagementFail, + FederationManagementFatal + }; + + virtual FederationManagementResult createFederationExecution(const std::string& federation, const std::string& objectModel) = 0; + virtual FederationManagementResult destroyFederationExecution(const std::string& federation) = 0; /// Join with federateName the federation execution federation - virtual bool join(const std::string& federateType, const std::string& federation) = 0; + virtual FederationManagementResult join(const std::string& federateType, const std::string& federation) = 0; virtual bool resign() = 0; /// Synchronization Point handling @@ -69,6 +67,9 @@ public: virtual bool modifyLookahead(const SGTimeStamp& timeStamp) = 0; virtual bool queryLookahead(SGTimeStamp& timeStamp) = 0; + virtual bool queryGALT(SGTimeStamp& timeStamp) = 0; + virtual bool queryLITS(SGTimeStamp& timeStamp) = 0; + /// Process messages virtual bool tick() = 0; virtual bool tick(const double& minimum, const double& maximum) = 0; @@ -78,21 +79,9 @@ public: virtual RTIObjectInstance* getObjectInstance(const std::string& name) = 0; -protected: - void setFederateType(const std::string& federateType) - { _federateType = federateType; } - void setFederationName(const std::string& federationName) - { _federationName = federationName; } - private: RTIFederate(const RTIFederate&); RTIFederate& operator=(const RTIFederate&); - - /// The federates name - std::string _federateType; - - /// The federation execution name - std::string _federationName; }; } diff --git a/simgear/hla/RTIObjectInstance.hxx b/simgear/hla/RTIObjectInstance.hxx index fb8f096a..3edbed60 100644 --- a/simgear/hla/RTIObjectInstance.hxx +++ b/simgear/hla/RTIObjectInstance.hxx @@ -50,9 +50,6 @@ public: unsigned getAttributeIndex(const std::string& name) const; std::string getAttributeName(unsigned index) const; - // FIXME: factor out an ambassador base - virtual void addToRequestQueue() = 0; - virtual void deleteObjectInstance(const RTIData& tag) = 0; virtual void deleteObjectInstance(const SGTimeStamp& timeStamp, const RTIData& tag) = 0; virtual void localDeleteObjectInstance() = 0; @@ -213,7 +210,6 @@ public: if (request) { if (!_pendingAttributeUpdateRequest) { _pendingAttributeUpdateRequest = true; - addToRequestQueue(); } } } diff --git a/simgear/scene/sky/cloud.cxx b/simgear/scene/sky/cloud.cxx index 19d5c70c..a3cf4ffe 100644 --- a/simgear/scene/sky/cloud.cxx +++ b/simgear/scene/sky/cloud.cxx @@ -78,9 +78,6 @@ static osg::ref_ptr layer_states[SGCloudLayer::SG_MAX_CLOUD_COVER static osg::ref_ptr layer_states2[SGCloudLayer::SG_MAX_CLOUD_COVERAGES]; static osg::ref_ptr cubeMap; static bool state_initialized = false; -static bool bump_mapping = false; - -bool SGCloudLayer::enable_bump_mapping = false; const std::string SGCloudLayer::SG_CLOUD_OVERCAST_STRING = "overcast"; const std::string SGCloudLayer::SG_CLOUD_BROKEN_STRING = "broken"; @@ -381,18 +378,6 @@ SGCloudLayer::rebuild() SG_LOG(SG_ASTRO, SG_INFO, "initializing cloud layers"); - osg::Texture::Extensions* extensions; - extensions = osg::Texture::getExtensions(0, true); - // OSGFIXME - bump_mapping = extensions->isMultiTexturingSupported() && - (2 <= extensions->numTextureUnits()) && - SGIsOpenGLExtensionSupported("GL_ARB_texture_env_combine") && - SGIsOpenGLExtensionSupported("GL_ARB_texture_env_dot3"); - - osg::TextureCubeMap::Extensions* extensions2; - extensions2 = osg::TextureCubeMap::getExtensions(0, true); - bump_mapping = bump_mapping && extensions2->isCubeMapSupported(); - // This bump mapping code was inspired by the tutorial available at // http://www.paulsprojects.net/tutorials/simplebump/simplebump.html // and a NVidia white paper diff --git a/simgear/scene/sky/cloud.hxx b/simgear/scene/sky/cloud.hxx index fa65a6ad..95f6dbbe 100644 --- a/simgear/scene/sky/cloud.hxx +++ b/simgear/scene/sky/cloud.hxx @@ -227,8 +227,6 @@ public: osg::Switch* getNode() { return cloud_root.get(); } - static bool enable_bump_mapping; - /** return the 3D layer cloud associated with this 2D layer */ SGCloudField *get_layer3D(void) { return layer3D; }