Changeset 6:8dd4ca9966d0 in xplra for src

Timestamp:

01/03/13 19:09:46 (12 years ago)

Author:

István Váradi <ivaradi@…>

Branch:

default

Phase:

public

Message:

Made all the single query operation work for all types

Location:

src/xplra

Files:

• DataRefTask.h (modified) (2 diffs)
• GetDataRefTask.cc (modified) (2 diffs)
• GetDataRefTask.h (modified) (8 diffs)
• Makefile.am (modified) (1 diff)
• Protocol.h (modified) (1 diff)
• ServerThread.cc (modified) (2 diffs)
• ServerThread.h (modified) (1 diff)

src/xplra/DataRefTask.h

@@ -72 +72 @@
     DataRefTask(XPLMDataRef dataRef);
 
+public:
     /**
      * Determine if the task is valid, which is so, if the dataref is
@@ -88 +89 @@
     XPLMDataRef getDataRef() const;
 
+protected:
     /**
      * Perform the task. If the dataref is not valid yet, it will be

src/xplra/GetDataRefTask.cc

@@ -30 +30 @@
 
 #include "GetDataRefTask.h"
+#include "Protocol.h"
 
 #include "xplcommon/Util.h"
@@ -35 +36 @@
 //------------------------------------------------------------------------------
 
+using xplra::GetDataRefTask;
+using xplra::GetIntDataRefTask;
+using xplra::GetFloatDataRefTask;
+using xplra::GetDoubleDataRefTask;
+
+using xplcommon::DataStream;
+
+using std::string;
+
+//------------------------------------------------------------------------------
+
+GetDataRefTask* GetDataRefTask::create(uint8_t& result, DataStream& stream)
+{
+    result = Protocol::RESULT_OK;
+
+    string name = stream.readString();
+    uint8_t type = stream.readU8();
+    if (!stream) return 0;
+
+    if (type==Protocol::TYPE_INT) {
+        return new GetIntDataRefTask(name);
+    } else if (type==Protocol::TYPE_FLOAT) {
+        return new GetFloatDataRefTask(name);
+    } else if (type==Protocol::TYPE_DOUBLE) {
+        return new GetDoubleDataRefTask(name);
+    } else if (type==Protocol::TYPE_FLOAT_ARRAY ||
+               type==Protocol::TYPE_INT_ARRAY ||
+               type==Protocol::TYPE_BYTE_ARRAY)
+    {
+        int length = stream.readS32();
+        int offset = stream.readS32();
+        if (!stream) return 0;
+
+        if (type==Protocol::TYPE_FLOAT_ARRAY) {
+            return new GetFloatArrayDataRefTask(name, length, offset);
+        } else if (type==Protocol::TYPE_INT_ARRAY) {
+            return new GetIntArrayDataRefTask(name, length, offset);
+        } else {
+            return new GetByteArrayDataRefTask(name, length, offset);
+        }
+    } else {
+        result = Protocol::RESULT_INVALID_TYPE;
+        return 0;
+    }
+}
+
+//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
+
+void GetIntDataRefTask::writeValue(DataStream& stream)
+{
+    stream.writeS32(getValue());
+}
+
+//------------------------------------------------------------------------------
+
+void GetFloatDataRefTask::writeValue(DataStream& stream)
+{
+    stream.writeFloat(getValue());
+}
+
+//------------------------------------------------------------------------------
+
+void GetDoubleDataRefTask::writeValue(DataStream& stream)
+{
+    stream.writeDouble(getValue());
+}
 
 //------------------------------------------------------------------------------

src/xplra/GetDataRefTask.h

@@ -33 +33 @@
 #include "DataRefTask.h"
 
+#include <xplcommon/DataStream.h>
+
 //------------------------------------------------------------------------------
 
@@ -46 +48 @@
 public:
     /**
+     * Read a dataref query specification and create the appropriate
+     * GetDataRefTask instance.
+     *
+     * @return the new instance, or 0 on error. In that case the given
+     * result reference variable will be filled with the error code,
+     * unless the stream failed, in which case it remains RESULT_OK.
+     */
+    static GetDataRefTask* create(uint8_t& result, xplcommon::DataStream& stream);
+
+    /**
      * Construct the task for the dataref with the given name.
      */
@@ -54 +66 @@
      */
     GetDataRefTask(XPLMDataRef dataRef);
+
+    /**
+     * Write the value into the given stream.
+     */
+    virtual void writeValue(xplcommon::DataStream& stream) = 0;
 };
 
@@ -120 +137 @@
      */
     GetIntDataRefTask(XPLMDataRef dataRef);
+
+    /**
+     * Write the value into the given stream.
+     */
+    virtual void writeValue(xplcommon::DataStream& stream);
 };
 
@@ -147 +169 @@
      */
     GetFloatDataRefTask(XPLMDataRef dataRef);
+
+    /**
+     * Write the value into the given stream.
+     */
+    virtual void writeValue(xplcommon::DataStream& stream);
 };
 
@@ -174 +201 @@
      */
     GetDoubleDataRefTask(XPLMDataRef dataRef);
+
+    /**
+     * Write the value into the given stream.
+     */
+    virtual void writeValue(xplcommon::DataStream& stream);
 };
 
@@ -253 +285 @@
      */
     virtual void process();
+
+    /**
+     * Write the value into the given stream.
+     */
+    virtual void writeValue(xplcommon::DataStream& stream);
 };
 
@@ -493 +530 @@
 
 //------------------------------------------------------------------------------
+
+template <typename T, class ConcreteClass>
+void GetArrayDataRefTask<T, ConcreteClass>::
+writeValue(xplcommon::DataStream& stream)
+{
+    stream.writeS32(length);
+    if (length>0) {
+        stream.write(data, length * sizeof(T));
+    }
+}
+
+//------------------------------------------------------------------------------
 // Inline definitions
 //------------------------------------------------------------------------------

src/xplra/Makefile.am

@@ -29 +29 @@
         ServerThread.cc         \
         TaskRequest.cc          \
-        DataRefTask.cc
+        DataRefTask.cc          \
+        GetDataRefTask.cc
 
 libxplra_la_LIBADD=$(LIBXPLCOMMON_LIBS)

src/xplra/Protocol.h

@@ -44 +44 @@
      * Command: get the value of a single dataref.
      */
-    static const uint8_t CMD_GET_SINGLE = 0x01;
+    static const uint8_t COMMAND_GET_SINGLE = 0x01;
 
     /**

src/xplra/ServerThread.cc

@@ -110 +110 @@
         //             this, command);
 
-        if (command==Protocol::CMD_GET_SINGLE) {
-            string name = stream.readString();
-            uint8_t type = stream.readU8();
-            if (!stream) continue;
-            // Util::debug("hu.varadiistvan.xplra.ServerThread[%p]::run: name='%s', type=0x%02x\n",
-            //             this, name.c_str(), type);
-            if (type==Protocol::TYPE_BYTE_ARRAY) {
-                int length = stream.readS32();
-                if (!stream) continue;
-
-                // Util::debug("hu.varadiistvan.xplra.ServerThread[%p]::run: length=%lu\n",
-                //             this, static_cast<unsigned long>(length));
-
-                GetByteArrayDataRefTask* task =
-                    new GetByteArrayDataRefTask(name, length);
-                TaskRequest request(task);
-
-                if (requestQueue.execute(&request)) {
-                    // Util::debug("hu.varadiistvan.xplra.ServerThread[%p]::run: request executed\n");
-                    stream.writeU8(Protocol::RESULT_OK);
-                    int length = task->getLength();
-                    stream.writeS32(length);
-                    if (length>0) {
-                        stream.write(task->getData(), length);
-                    }
-                } else {
-                    break;
-                }
-            } else {
-                stream.writeU8(Protocol::RESULT_OTHER_ERROR);
-            }
+        if (command==Protocol::COMMAND_GET_SINGLE) {
+            if (!handleGetSingle(stream)) break;
         } else {
             stream.writeU8(Protocol::RESULT_INVALID_COMMAND);
@@ -152 +123 @@
 //------------------------------------------------------------------------------
 
+bool ServerThread::handleGetSingle(xplcommon::DataStream& stream)
+{
+    uint8_t result = Protocol::RESULT_OK;
+
+    GetDataRefTask* task = GetDataRefTask::create(result, stream);
+
+    if (!stream) return false;
+    else if (task==0) {
+        stream.writeU8(Protocol::RESULT_INVALID_TYPE);
+        return true;
+    }
+
+    TaskRequest request(task);
+    if (!requestQueue.execute(&request)) return false;
+
+    if (task->isValid()) {
+        stream.writeU8(Protocol::RESULT_OK);
+        task->writeValue(stream);
+    } else {
+        stream.writeU8(Protocol::RESULT_UNKNOWN_DATAREF);
+    }
+
+    return true;
+}
+
+//------------------------------------------------------------------------------
+
 // Local Variables:
 // mode: C++

src/xplra/ServerThread.h

@@ -122 +122 @@
      */
     virtual void run();
+
+private:
+    /**
+     * Handle the COMMAND_GET_SINGLE command
+     *
+     * @return true, if we can continue, false if the thread should quit
+     */
+    bool handleGetSingle(xplcommon::DataStream& stream);
 };