Gats for QT is here. It's a pretty basic conversion right now, it doesn't

support debugging formatting (Bu::sio), it doesn't support gats-text string
parsing, and the exceptions need to be fixed to be real exceptions.

The basic functions have been renamed to match the Qt API and we use QT types
for everything (QHash, QList, QByteArray).  It needs more testing, but it's a
great start.

1 files changed, 57 insertions, 0 deletions

diff --git a/c++-qt/src/gatsstream.h b/c++-qt/src/gatsstream.h
new file mode 100644
index 0000000..3cf1081
--- /dev/null
+++ b/c++-qt/src/gatsstream.h
@@ -0,0 +1,57 @@
+#ifndef GATS_STREAM_H
+#define GATS_STREAM_H
+
+#include <QIODevice>
+#include <QByteArray>
+
+namespace Gats
+{
+        class Object;
+
+        class GatsStream : public QObject
+        {
+                Q_OBJECT;
+        public:
+                GatsStream( QIODevice &rStream );
+                virtual ~GatsStream();
+
+                /**
+                 * Read an object packet from the assosiated stream.  This will make
+                 * every effort to only read exactly enough data to describe one packet,
+                 * in case you want to do other things with your stream.  It will
+                 * automatically skip NULL byte spacing between packets, which makes
+                 * a convinient padding method for encrypted data streams.  Since
+                 * sizing information is available in the packet header exact amounts
+                 * of data can be read, however this function doesn't assume that it
+                 * can read the entire object in one operation.  If it fails to read
+                 * a complete packet in one call, it will keep the data it's read so
+                 * far buffered and return NULL, ready for another attempt.  You can
+                 * use the function hasReadBuffer() to deterimne if readObject()
+                 * has read part of an object packet or not.  If readObject returns
+                 * non-null then hasReadBuffer should return false on it's next call.
+                 */
+                Gats::Object *readObject();
+
+                /**
+                 * Write an object 
+                 */
+                void writeObject( Gats::Object *pObject );
+
+                /**
+                 * Tells you if there is data still in the read buffer, i.e. that a
+                 * packet is part way through being read.  If readObject has returned
+                 * non-null in the most recent call, this should always be false.
+                 */
+                bool hasReadBuffer() { return qbRead.size() > 0; }
+                int getReadBufferSize() { return qbRead.size(); }
+
+        private:
+                bool skipReadNulls();
+
+        private:
+                QIODevice &rStream;
+                QByteArray qbRead;
+        };
+};
+
+#endif