hla: Fix buffer overrun in SGMath vector types.

[simgear.git] / simgear / hla / RTI13Ambassador.hxx

diff --git a/simgear/hla/RTI13Ambassador.hxx b/simgear/hla/RTI13Ambassador.hxx
index 2465e349cc9bfd83a0d48f61b84b066edc1524c4..85779fa7a037bbc321491341c43515fed5706114 100644 (file)
--- a/simgear/hla/RTI13Ambassador.hxx
+++ b/simgear/hla/RTI13Ambassador.hxx
@@ -71,11 +71,22 @@ public:
     { _rtiAmbassador.publishObjectClass(handle, attributeHandleSet); }
     void unpublishObjectClass(const RTI::ObjectClassHandle& handle)
     { _rtiAmbassador.unpublishObjectClass(handle); }
+
+    void publishInteractionClass(const RTI::InteractionClassHandle& handle)
+    { _rtiAmbassador.publishInteractionClass(handle); }
+    void unpublishInteractionClass(const RTI::InteractionClassHandle& handle)
+    { _rtiAmbassador.unpublishInteractionClass(handle); }
+
     void subscribeObjectClassAttributes(const RTI::ObjectClassHandle& handle, const RTI::AttributeHandleSet& attributeHandleSet, bool active)
     { _rtiAmbassador.subscribeObjectClassAttributes(handle, attributeHandleSet, active ? RTI::RTI_TRUE : RTI::RTI_FALSE); }
     void unsubscribeObjectClass(const RTI::ObjectClassHandle& handle)
     { _rtiAmbassador.unsubscribeObjectClass(handle); }
 
+    void subscribeInteractionClass(const RTI::InteractionClassHandle& handle, bool active)
+    { _rtiAmbassador.subscribeInteractionClass(handle, active ? RTI::RTI_TRUE : RTI::RTI_FALSE); }
+    void unsubscribeInteractionClass(const RTI::InteractionClassHandle& handle)
+    { _rtiAmbassador.unsubscribeInteractionClass(handle); }
+
     RTI::ObjectHandle registerObjectInstance(const RTI::ObjectClassHandle& handle)
     { return _rtiAmbassador.registerObjectInstance(handle); }
     void updateAttributeValues(const RTI::ObjectHandle& objectHandle, const RTI::AttributeHandleValuePairSet& attributeValues,
@@ -90,7 +101,7 @@ 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()); }
+    { /* RTI::EventRetractionHandle h = */ _rtiAmbassador.deleteObjectInstance(objectHandle, toFedTime(timeStamp), tag.data()); }
     void deleteObjectInstance(const RTI::ObjectHandle& objectHandle, const RTIData& tag)
     { _rtiAmbassador.deleteObjectInstance(objectHandle, tag.data()); }
     void localDeleteObjectInstance(const RTI::ObjectHandle& objectHandle)
@@ -264,25 +275,17 @@ public:
     //     }
     //     return false;
     // }
-    // bool isAttributeOwnedByFederate(const RTIHandle& objectHandle, const RTIHandle& attributeHandle)
-    // {
-    //     try {
-    //         return _rtiAmbassador.isAttributeOwnedByFederate(objectHandle, attributeHandle);
-    //     } catch (RTI::ObjectNotKnown& e) {
-    //     } catch (RTI::AttributeNotDefined& e) {
-    //     } catch (RTI::FederateNotExecutionMember& e) {
-    //     } catch (RTI::ConcurrentAccessAttempted& e) {
-    //     } catch (RTI::SaveInProgress& e) {
-    //     } catch (RTI::RestoreInProgress& e) {
-    //     } catch (RTI::RTIinternalError& e) {
-    //     }
-    //     return false;
-    // }
+    bool isAttributeOwnedByFederate(const RTI::ObjectHandle& objectHandle, const RTI::AttributeHandle& attributeHandle)
+    { return _rtiAmbassador.isAttributeOwnedByFederate(objectHandle, attributeHandle); }
 
     /// 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();}
 
@@ -295,22 +298,29 @@ public:
     { _rtiAmbassador.timeAdvanceRequest(toFedTime(time)); }
     void timeAdvanceRequestAvailable(const SGTimeStamp& time)
     { _rtiAmbassador.timeAdvanceRequestAvailable(toFedTime(time)); }
+    void flushQueueRequest(const SGTimeStamp& time)
+    { _rtiAmbassador.flushQueueRequest(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;
@@ -336,55 +346,15 @@ public:
     std::string getAttributeName(const RTI::AttributeHandle& attributeHandle, const RTI::ObjectClassHandle& objectClassHandle)
     { return rtiToStdString(_rtiAmbassador.getAttributeName(attributeHandle, objectClassHandle)); }
 
-    // RTIHandle getInteractionClassHandle(const std::string& name)
-    // {
-    //     try {
-    //         return _rtiAmbassador.getInteractionClassHandle(name.c_str());
-    //     } catch (RTI::NameNotFound& e) {
-    //     } catch (RTI::FederateNotExecutionMember& e) {
-    //     } catch (RTI::ConcurrentAccessAttempted& e) {
-    //     } catch (RTI::RTIinternalError& e) {
-    //     }
-    //     return RTIHandle(-1);
-    // }
-    // std::string getInteractionClassName(const RTIHandle& handle)
-    // {
-    //     std::string name;
-    //     try {
-    //         rtiToStdString(name, _rtiAmbassador.getInteractionClassName(handle));
-    //     } catch (RTI::InteractionClassNotDefined& e) {
-    //     } catch (RTI::FederateNotExecutionMember& e) {
-    //     } catch (RTI::ConcurrentAccessAttempted& e) {
-    //     } catch (RTI::RTIinternalError& e) {
-    //     }
-    //     return name;
-    // }
+    RTI::InteractionClassHandle getInteractionClassHandle(const std::string& name)
+    { return _rtiAmbassador.getInteractionClassHandle(name.c_str()); }
+    std::string getInteractionClassName(const RTI::InteractionClassHandle& handle)
+    { return rtiToStdString(_rtiAmbassador.getInteractionClassName(handle)); }
 
-    // RTIHandle getParameterHandle(const std::string& parameterName, const RTIHandle& interactionClassHandle)
-    // {
-    //     try {
-    //         return _rtiAmbassador.getParameterHandle(parameterName.c_str(), interactionClassHandle);
-    //     } catch (RTI::InteractionClassNotDefined& e) {
-    //     } catch (RTI::NameNotFound& e) {
-    //     } catch (RTI::FederateNotExecutionMember& e) {
-    //     } catch (RTI::ConcurrentAccessAttempted& e) {
-    //     } catch (RTI::RTIinternalError& e) {
-    //     }
-    //     return RTIHandle(-1);
-    // }
-    // std::string getParameterName(const RTIHandle& parameterHandle, const RTIHandle& interactionClassHandle)
-    // {
-    //     std::string parameterName;
-    //     try {
-    //         rtiToStdString(parameterName, _rtiAmbassador.getParameterName(parameterHandle, interactionClassHandle));
-    //     } catch (RTI::InteractionClassNotDefined& e) {
-    //     } catch (RTI::InteractionParameterNotDefined& e) {
-    //     } catch (RTI::FederateNotExecutionMember& e) {
-    //     } catch (RTI::ConcurrentAccessAttempted& e) {
-    //     } catch (RTI::RTIinternalError& e) {
-    //     }
-    //     return parameterName;
-    // }
+    RTI::ParameterHandle getParameterHandle(const std::string& parameterName, const RTI::InteractionClassHandle& interactionClassHandle)
+    { return _rtiAmbassador.getParameterHandle(parameterName.c_str(), interactionClassHandle); }
+    std::string getParameterName(const RTI::ParameterHandle& parameterHandle, const RTI::InteractionClassHandle& interactionClassHandle)
+    { return rtiToStdString(_rtiAmbassador.getParameterName(parameterHandle, interactionClassHandle)); }
 
     RTI::ObjectHandle getObjectInstanceHandle(const std::string& name)
     { return _rtiAmbassador.getObjectInstanceHandle(name.c_str()); }