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.

18 files changed, 1648 insertions, 0 deletions

diff --git a/c++-qt/src/boolean.cpp b/c++-qt/src/boolean.cpp
new file mode 100644
index 0000000..9610f50
--- /dev/null
+++ b/c++-qt/src/boolean.cpp
@@ -0,0 +1,47 @@
+#include "gats-qt/boolean.h"
+
+#include <QIODevice>
+
+Gats::Boolean::Boolean() :
+        bVal( false )
+{
+}
+
+Gats::Boolean::Boolean( bool bVal ) :
+        bVal( bVal )
+{
+}
+
+Gats::Boolean::~Boolean()
+{
+}
+
+void Gats::Boolean::write( QIODevice &rOut ) const
+{
+        if( bVal )
+        {
+                rOut.write("1", 1 ); 
+        }
+        else
+        {
+                rOut.write("0", 1 );
+        }
+}
+
+void Gats::Boolean::read( QIODevice &rIn, char cType )
+{
+        if( cType == '1' )
+        {
+                bVal = true;
+        }
+        else
+        {
+                bVal = false;
+        }
+}
+/*
+Bu::Formatter &operator<<( Bu::Formatter &f, const Gats::Boolean &b )
+{
+        return f << "(bool) " << b.getValue();
+}
+*/
diff --git a/c++-qt/src/boolean.h b/c++-qt/src/boolean.h
new file mode 100644
index 0000000..4eec690
--- /dev/null
+++ b/c++-qt/src/boolean.h
@@ -0,0 +1,32 @@
+#ifndef GATS_BOOLEAN_H
+#define GATS_BOOLEAN_H
+
+#include "gats-qt/object.h"
+
+class QIODevice;
+
+namespace Gats
+{
+        class Boolean : public Gats::Object
+        {
+                Q_OBJECT;
+        public:
+                Boolean();
+                Boolean( bool bVal );
+                virtual ~Boolean();
+
+                virtual Type getType() const { return typeBoolean; }
+                bool getValue() const { return bVal; }
+                void setValue( bool b ) { bVal = b; }
+
+                virtual void write( QIODevice &rOut ) const;
+                virtual void read( QIODevice &rIn, char cType );
+
+        private:
+                bool bVal;
+        };
+};
+
+//Bu::Formatter &operator<<( Bu::Formatter &f, const Gats::Boolean &b );
+
+#endif
diff --git a/c++-qt/src/dictionary.cpp b/c++-qt/src/dictionary.cpp
new file mode 100644
index 0000000..ad4759a
--- /dev/null
+++ b/c++-qt/src/dictionary.cpp
@@ -0,0 +1,349 @@
+#include "gats-qt/dictionary.h"
+
+#include "gats-qt/boolean.h"
+#include "gats-qt/integer.h"
+#include "gats-qt/float.h"
+#include "gats-qt/string.h"
+#include "gats-qt/list.h"
+
+Gats::Dictionary::Dictionary()
+{
+}
+
+Gats::Dictionary::~Dictionary()
+{
+        for( iterator i = begin(); i != end(); i++ )
+        {
+                delete *i;
+        }
+}
+
+void Gats::Dictionary::write( QIODevice &rOut ) const
+{
+        rOut.write("d", 1 );
+        for( const_iterator i= begin(); i != end(); i++ )
+        {
+                Gats::String s( i.key() );
+                s.write( rOut );
+                (*i)->write( rOut );
+        }
+        rOut.write("e", 1 );
+}
+
+void Gats::Dictionary::read( QIODevice &rIn, char cType )
+{
+        for(;;)
+        {
+                char cNext;
+                rIn.read( &cNext, 1 );
+                if( cNext == 'e' )
+                        break;
+                if( cNext != 's' )
+                        throw "PUT GOOD EXCEPTION HERE";
+                Gats::String sKey;
+                sKey.read( rIn, cNext );
+
+                ((QHash<QByteArray, Gats::Object *> *)this)->insert(
+                        sKey, Gats::Object::read( rIn )
+                        );
+        }
+}
+
+void Gats::Dictionary::insert( const QByteArray &sKey, char i )
+{
+        ((QHash<QByteArray, Gats::Object *> *)this)->insert(
+                sKey, new Gats::Integer( i )
+                );
+}
+
+void Gats::Dictionary::insert( const QByteArray &sKey, unsigned char i )
+{
+        ((QHash<QByteArray, Gats::Object *> *)this)->insert(
+                sKey, new Gats::Integer( i )
+                );
+}
+
+void Gats::Dictionary::insert( const QByteArray &sKey, signed char i )
+{
+        ((QHash<QByteArray, Gats::Object *> *)this)->insert(
+                sKey, new Gats::Integer( i )
+                );
+}
+
+void Gats::Dictionary::insert( const QByteArray &sKey, unsigned short i )
+{
+        ((QHash<QByteArray, Gats::Object *> *)this)->insert(
+                sKey, new Gats::Integer( i )
+                );
+}
+
+void Gats::Dictionary::insert( const QByteArray &sKey, signed short i )
+{
+        ((QHash<QByteArray, Gats::Object *> *)this)->insert(
+                sKey, new Gats::Integer( i )
+                );
+}
+
+void Gats::Dictionary::insert( const QByteArray &sKey, unsigned int i )
+{
+        ((QHash<QByteArray, Gats::Object *> *)this)->insert(
+                sKey, new Gats::Integer( i )
+                );
+}
+
+void Gats::Dictionary::insert( const QByteArray &sKey, signed int i )
+{
+        ((QHash<QByteArray, Gats::Object *> *)this)->insert(
+                sKey, new Gats::Integer( i )
+                );
+}
+
+void Gats::Dictionary::insert( const QByteArray &sKey, unsigned long i )
+{
+        ((QHash<QByteArray, Gats::Object *> *)this)->insert(
+                sKey, new Gats::Integer( i )
+                );
+}
+
+void Gats::Dictionary::insert( const QByteArray &sKey, signed long i )
+{
+        ((QHash<QByteArray, Gats::Object *> *)this)->insert(
+                sKey, new Gats::Integer( i )
+                );
+}
+
+void Gats::Dictionary::insert( const QByteArray &sKey, unsigned long long i )
+{
+        ((QHash<QByteArray, Gats::Object *> *)this)->insert(
+                sKey, new Gats::Integer( i )
+                );
+}
+
+void Gats::Dictionary::insert( const QByteArray &sKey, signed long long i )
+{
+        ((QHash<QByteArray, Gats::Object *> *)this)->insert(
+                sKey, new Gats::Integer( i )
+                );
+}
+/*
+void Gats::Dictionary::insert( const QByteArray &sKey, bool b )
+{
+        QHash<QByteArray, Gats::Object *>::insert(
+                sKey, new Gats::Boolean( b )
+                );
+}*/
+
+void Gats::Dictionary::insert( const QByteArray &sKey, float d )
+{
+        QHash<QByteArray, Gats::Object *>::insert(
+                sKey, new Gats::Float( d )
+                );
+}
+
+void Gats::Dictionary::insert( const QByteArray &sKey, double d )
+{
+        QHash<QByteArray, Gats::Object *>::insert(
+                sKey, new Gats::Float( d )
+                );
+}
+
+void Gats::Dictionary::insert( const QByteArray &sKey, const char *s )
+{
+        QHash<QByteArray, Gats::Object *>::insert(
+                sKey, new Gats::String( s )
+                );
+}
+
+void Gats::Dictionary::insert( const QByteArray &sKey, const QByteArray &s )
+{
+        QHash<QByteArray, Gats::Object *>::insert(
+                sKey, new Gats::String( s )
+                );
+}
+
+void Gats::Dictionary::insertBool( const QByteArray &sKey, bool b )
+{
+        QHash<QByteArray, Gats::Object *>::insert(
+                sKey, new Gats::Boolean( b )
+                );
+}
+
+void Gats::Dictionary::insertInt( const QByteArray &sKey, int64_t i )
+{
+        QHash<QByteArray, Gats::Object *>::insert(
+                sKey, new Gats::Integer( i )
+                );
+}
+
+void Gats::Dictionary::insertFloat( const QByteArray &sKey, double d )
+{
+        QHash<QByteArray, Gats::Object *>::insert(
+                sKey, new Gats::Float( d )
+                );
+}
+
+void Gats::Dictionary::insertStr( const QByteArray &sKey, const QByteArray &s )
+{
+        QHash<QByteArray, Gats::Object *>::insert(
+                sKey, new Gats::String( s )
+                );
+}
+
+void Gats::Dictionary::insertList( const QByteArray &sKey, Gats::List *pL )
+{
+        QHash<QByteArray, Gats::Object *>::insert(
+                sKey, pL
+                );
+}
+
+void Gats::Dictionary::insertDict( const QByteArray &sKey,
+                Gats::Dictionary *pD )
+{
+        QHash<QByteArray, Gats::Object *>::insert(
+                sKey, pD
+                );
+}
+
+Gats::List *Gats::Dictionary::insertList( const QByteArray &sKey )
+{
+        Gats::List *pLst = new Gats::List();
+        insertList( sKey, pLst );
+        return pLst;
+}
+
+Gats::Dictionary *Gats::Dictionary::insertDict( const QByteArray &sKey )
+{
+        Gats::Dictionary *pDict = new Gats::Dictionary();
+        insertDict( sKey, pDict );
+        return pDict;
+}
+
+bool Gats::Dictionary::valueBool( const QByteArray &sKey )
+{
+        Gats::Boolean *pOb = dynamic_cast<Gats::Boolean *>( value( sKey ) );
+        if( !pOb )
+                throw "PUT GOOD EXCEPTION HERE";
+
+        return pOb->getValue();
+}
+
+int64_t Gats::Dictionary::valueInt( const QByteArray &sKey )
+{
+        Gats::Integer *pOb = dynamic_cast<Gats::Integer *>( value( sKey ) );
+        if( !pOb )
+                throw "PUT GOOD EXCEPTION HERE";
+
+        return pOb->getValue();
+}
+
+double Gats::Dictionary::valueFloat( const QByteArray &sKey )
+{
+        Gats::Float *pOb = dynamic_cast<Gats::Float *>( value( sKey ) );
+        if( !pOb )
+                throw "PUT GOOD EXCEPTION HERE";
+
+        return pOb->getValue();
+}
+
+QByteArray Gats::Dictionary::valueStr( const QByteArray &sKey )
+{
+        Gats::String *pOb = dynamic_cast<Gats::String *>( value( sKey ) );
+        if( !pOb )
+                throw "PUT GOOD EXCEPTION HERE";
+
+        return *pOb;
+}
+
+Gats::List *Gats::Dictionary::valueList( const QByteArray &sKey )
+{
+        Gats::List *pOb = dynamic_cast<Gats::List *>( value( sKey ) );
+        if( !pOb )
+                throw "PUT GOOD EXCEPTION HERE";
+
+        return pOb;
+}
+
+Gats::Dictionary *Gats::Dictionary::valueDict( const QByteArray &sKey )
+{
+        Gats::Dictionary *pOb = dynamic_cast<Gats::Dictionary *>( value( sKey ) );
+        if( !pOb )
+                throw "PUT GOOD EXCEPTION HERE";
+
+        return pOb;
+}
+
+bool Gats::Dictionary::valueBool( const QByteArray &sKey ) const
+{
+        Gats::Boolean *pOb = dynamic_cast<Gats::Boolean *>( value( sKey ) );
+        if( !pOb )
+                throw "PUT GOOD EXCEPTION HERE";
+
+        return pOb->getValue();
+}
+
+int64_t Gats::Dictionary::valueInt( const QByteArray &sKey ) const
+{
+        Gats::Integer *pOb = dynamic_cast<Gats::Integer *>( value( sKey ) );
+        if( !pOb )
+                throw "PUT GOOD EXCEPTION HERE";
+
+        return pOb->getValue();
+}
+
+double Gats::Dictionary::valueFloat( const QByteArray &sKey ) const
+{
+        Gats::Float *pOb = dynamic_cast<Gats::Float *>( value( sKey ) );
+        if( !pOb )
+                throw "PUT GOOD EXCEPTION HERE";
+
+        return pOb->getValue();
+}
+
+QByteArray Gats::Dictionary::valueStr( const QByteArray &sKey ) const
+{
+        Gats::String *pOb = dynamic_cast<Gats::String *>( value( sKey ) );
+        if( !pOb )
+                throw "PUT GOOD EXCEPTION HERE";
+
+        return *pOb;
+}
+
+Gats::List *Gats::Dictionary::valueList( const QByteArray &sKey ) const
+{
+        Gats::List *pOb = dynamic_cast<Gats::List *>( value( sKey ) );
+        if( !pOb )
+                throw "PUT GOOD EXCEPTION HERE";
+
+        return pOb;
+}
+
+Gats::Dictionary *Gats::Dictionary::valueDict( const QByteArray &sKey ) const
+{
+        Gats::Dictionary *pOb = dynamic_cast<Gats::Dictionary *>( value( sKey ) );
+        if( !pOb )
+                throw "PUT GOOD EXCEPTION HERE";
+
+        return pOb;
+}
+/*
+Bu::Formatter &operator<<( Bu::Formatter &f, const Gats::Dictionary &d )
+{
+        f << "(dict) {";
+        f.incIndent();
+        int iMax = 0;
+        for( Gats::Dictionary::const_iterator i = d.begin(); i; i++ )
+        {
+                if( i.valueKey().valueSize() > iMax )
+                        iMax = i.valueKey().valueSize();
+        }
+        iMax += 2;
+        for( Gats::Dictionary::const_iterator i = d.begin(); i; i++ )
+        {
+                f << f.nl << Bu::Fmt( iMax ) << i.valueKey() + ": " << *i.getValue();
+        }
+        f.decIndent();
+        f << f.nl << "}";
+
+        return f;
+}
+*/
diff --git a/c++-qt/src/dictionary.h b/c++-qt/src/dictionary.h
new file mode 100644
index 0000000..6db94b2
--- /dev/null
+++ b/c++-qt/src/dictionary.h
@@ -0,0 +1,68 @@
+#ifndef GATS_DICTIONARY_H
+#define GATS_DICTIONARY_H
+
+#include "gats-qt/object.h"
+#include "gats-qt/string.h"
+#include <QHash>
+
+namespace Gats
+{
+        class List;
+
+        class Dictionary : public Gats::Object,
+                public QHash<QByteArray, Gats::Object *>
+        {
+                Q_OBJECT;
+        public:
+                Dictionary();
+                virtual ~Dictionary();
+
+                virtual Type getType() const { return typeDictionary; }
+                virtual void write( QIODevice &rOut ) const;
+                virtual void read( QIODevice &rIn, char cType );
+
+                void insert( const QByteArray &sKey, const char *s );
+                void insert( const QByteArray &sKey, const QByteArray &s );
+                void insert( const QByteArray &sKey, char i );
+                void insert( const QByteArray &sKey, unsigned char i );
+                void insert( const QByteArray &sKey, signed char i );
+                void insert( const QByteArray &sKey, unsigned short i );
+                void insert( const QByteArray &sKey, signed short i );
+                void insert( const QByteArray &sKey, unsigned int i );
+                void insert( const QByteArray &sKey, signed int i );
+                void insert( const QByteArray &sKey, unsigned long i );
+                void insert( const QByteArray &sKey, signed long i );
+                void insert( const QByteArray &sKey, unsigned long long i );
+                void insert( const QByteArray &sKey, signed long long i );
+                //void insert( const QByteArray &sKey, bool b );
+                void insert( const QByteArray &sKey, float d );
+                void insert( const QByteArray &sKey, double d );
+                using QHash<QByteArray, Gats::Object *>::insert;
+                void insertBool( const QByteArray &sKey, bool b );
+                void insertInt( const QByteArray &sKey, int64_t i );
+                void insertFloat( const QByteArray &sKey, double d );
+                void insertStr( const QByteArray &sKey, const QByteArray &s );
+                void insertList( const QByteArray &sKey, Gats::List *pL );
+                void insertDict( const QByteArray &sKey, Gats::Dictionary *pD );
+                Gats::List *insertList( const QByteArray &sKey );
+                Gats::Dictionary *insertDict( const QByteArray &sKey );
+
+                bool valueBool( const QByteArray &sKey );
+                int64_t valueInt( const QByteArray &sKey );
+                double valueFloat( const QByteArray &sKey );
+                QByteArray valueStr( const QByteArray &sKey );
+                Gats::List *valueList( const QByteArray &sKey );
+                Gats::Dictionary *valueDict( const QByteArray &sKey );
+                
+                bool valueBool( const QByteArray &sKey ) const;
+                int64_t valueInt( const QByteArray &sKey ) const;
+                double valueFloat( const QByteArray &sKey ) const;
+                QByteArray valueStr( const QByteArray &sKey ) const;
+                Gats::List *valueList( const QByteArray &sKey ) const;
+                Gats::Dictionary *valueDict( const QByteArray &sKey ) const;
+        };
+};
+
+//Bu::Formatter &operator<<( Bu::Formatter &f, const Gats::Dictionary &d );
+
+#endif
diff --git a/c++-qt/src/float.cpp b/c++-qt/src/float.cpp
new file mode 100644
index 0000000..a82edec
--- /dev/null
+++ b/c++-qt/src/float.cpp
@@ -0,0 +1,122 @@
+#include "gats-qt/float.h"
+#include "gats-qt/integer.h"
+
+#include <math.h>
+
+Gats::Float::Float() :
+        fVal( 0.0 )
+{
+}
+
+Gats::Float::Float( double f ) :
+        fVal( f )
+{
+}
+
+Gats::Float::~Float()
+{
+}
+
+void Gats::Float::write( QIODevice &rOut ) const
+{
+        if( fVal == 0.0 )
+        {
+                if( signbit( fVal ) )
+                        rOut.write("FZ", 2 );
+                else
+                        rOut.write("Fz", 2 );
+        }
+        else if( !isfinite( fVal ) )
+        {
+                if( isnan( fVal ) )
+                {
+                        if( signbit( fVal ) )
+                                rOut.write("FN", 2 );
+                        else
+                                rOut.write("Fn", 2 );
+                }
+                else
+                {
+                        if( signbit( fVal ) )
+                                rOut.write("FI", 2 );
+                        else
+                                rOut.write("Fi", 2 );
+                }
+        }
+        else
+        {
+                rOut.write("f", 1 );
+                double d = fVal;
+                bool bNeg = false;
+                int64_t iScale=0;
+                if( signbit( d ) )
+                {
+                        bNeg = true;
+                        d = -d;
+                }
+
+                iScale = log( d ) / 0x1.62e42fefa39efp+2; // log( 256.0 )
+                if( iScale < 0 ) iScale--;
+                d /= pow( 256.0, iScale );
+                
+                QByteArray s;
+                s += (uint8_t)(d);
+                d -= (int)d;
+                for( int j = 0; j < 150 && d; j++ )
+                {
+                        d = d*256.0;
+                        s += (uint8_t)d;
+                        d -= (int)d;
+                }
+                Gats::Integer::writePackedInt( rOut, bNeg?-s.size():s.size() );
+                rOut.write( s.constData(), s.size() );
+                Gats::Integer::writePackedInt( rOut, iScale );
+        }
+}
+
+void Gats::Float::read( QIODevice &rIn, char cType )
+{
+        if( cType == 'F' )
+        {
+                char buf;
+                rIn.read( &buf, 1 );
+                switch( buf )
+                {
+                        case 'N': fVal = -NAN;          break;
+                        case 'n': fVal = NAN;           break;
+                        case 'I': fVal = -INFINITY;     break;
+                        case 'i': fVal = INFINITY;      break;
+                        case 'Z': fVal = -0.0;          break;
+                        case 'z': fVal = 0.0;           break;
+                }
+        }
+        else if( cType == 'f' )
+        {
+                int64_t iStr;
+                Gats::Integer::readPackedInt( rIn, iStr );
+                bool bNeg = false;
+                if( iStr < 0 )
+                {
+                        bNeg = true;
+                        iStr = -iStr;
+                }
+                QByteArray s( iStr, '\0' );
+                rIn.read( s.data(), iStr );
+                fVal = 0.0;
+                for( int j = iStr-1; j > 0; j-- )
+                {
+                        fVal = (fVal+(uint8_t)s[j])*0x1p-8;
+                }
+                fVal += (uint8_t)s[0];
+                int64_t iScale;
+                Gats::Integer::readPackedInt( rIn, iScale );
+                fVal *= pow( 256.0, iScale );
+                if( bNeg ) fVal = -fVal;
+        }
+}
+/*
+Bu::Formatter &operator<<( Bu::Formatter &f, const Gats::Float &flt )
+{
+        return f << "(float) " << flt.getValue();
+}*/
+
diff --git a/c++-qt/src/float.h b/c++-qt/src/float.h
new file mode 100644
index 0000000..74225aa
--- /dev/null
+++ b/c++-qt/src/float.h
@@ -0,0 +1,30 @@
+#ifndef GATS_FLOAT_H
+#define GATS_FLOAT_H
+
+#include "gats-qt/object.h"
+
+namespace Gats
+{
+        class Float : public Gats::Object
+        {
+                Q_OBJECT;
+        public:
+                Float();
+                Float( double f );
+                virtual ~Float();
+
+                virtual Type getType() const { return typeFloat; }
+                double getValue() const { return fVal; }
+
+                virtual void write( QIODevice &rOut ) const;
+                virtual void read( QIODevice &rIn, char cType );
+
+        private:
+                double fVal;
+                mutable QByteArray sWriteCache;
+        };
+}
+
+//Bu::Formatter &operator<<( Bu::Formatter &f, const Gats::Float &flt );
+
+#endif
diff --git a/c++-qt/src/gatsstream.cpp b/c++-qt/src/gatsstream.cpp
new file mode 100644
index 0000000..d32b2b2
--- /dev/null
+++ b/c++-qt/src/gatsstream.cpp
@@ -0,0 +1,116 @@
+#include "gats-qt/gatsstream.h"
+#include "gats-qt/object.h"
+
+#ifdef WIN32
+#include <winsock2.h>
+#else
+#include <arpa/inet.h>
+#endif
+
+#include <QBuffer>
+
+Gats::GatsStream::GatsStream( QIODevice &rStream ) :
+        rStream( rStream )
+{
+}
+
+Gats::GatsStream::~GatsStream()
+{
+}
+
+Gats::Object *Gats::GatsStream::readObject()
+{
+        char buf[1500];
+
+        do
+        {
+                if( qbRead.size() < 5 )
+                {
+                        int iRead = rStream.read( buf, 5-qbRead.size() );
+                        qbRead.append( buf, iRead );
+
+                        if( qbRead.size() < 5 )
+                                return NULL;
+                }
+        } while( !skipReadNulls() );
+
+        uint8_t uVer;
+        uVer = qbRead[0];
+        
+        int32_t iSize;
+        memcpy( &iSize, qbRead.constData()+1, 4 );
+        iSize = ntohl( iSize );
+        while( qbRead.size() < iSize )
+        {
+                int32_t iRead = iSize - qbRead.size();
+                if( iRead > 1500 )
+                        iRead = 1500;
+                int32_t iReal = rStream.read( buf, iRead );
+                qbRead.append( buf, iReal );
+                if( iReal < iRead )
+                {
+                        return NULL;
+                }
+        }
+
+        if( qbRead.size() < iSize )
+        {
+                return NULL;
+        }
+
+        QBuffer rTmp( &qbRead );
+        rTmp.open( QIODevice::ReadOnly );
+        rTmp.seek( 5 );
+        Gats::Object *pObj = Gats::Object::read( rTmp );
+
+        return pObj;
+}
+
+void Gats::GatsStream::writeObject( Gats::Object *pObject )
+{
+        QIODevice *pTmp;
+        if( rStream.isSequential() )
+        {
+                pTmp = new QBuffer();
+                pTmp->open( QIODevice::WriteOnly );
+        }
+        else
+        {
+                pTmp = &rStream;
+        }
+
+        uint8_t uBuf = 1;
+        uint32_t iSize = 0;
+        pTmp->write( (const char *)&uBuf, 1 );
+        uint64_t iSizePos = pTmp->pos();
+        pTmp->write( (const char *)&iSize, 4 );
+        pObject->write( *pTmp );
+        iSize = htonl( pTmp->pos() );
+        pTmp->seek( iSizePos );
+        pTmp->write( (const char *)&iSize, 4 );
+        pTmp->close();
+
+        if( rStream.isSequential() )
+        {
+                rStream.write( ((QBuffer *)pTmp)->data() );
+                delete pTmp;
+        }
+}
+
+bool Gats::GatsStream::skipReadNulls()
+{
+        bool bHaveSeeked = false;
+        for(;;)
+        {
+                if( qbRead.size() == 0 )
+                        return false;
+                if( qbRead.at(0) != 0 )
+                        return !bHaveSeeked; //true;
+                else
+                {
+                        qbRead.remove( 0, 1 );
+                        bHaveSeeked = true;
+                }
+        }
+}
+
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
diff --git a/c++-qt/src/integer.cpp b/c++-qt/src/integer.cpp
new file mode 100644
index 0000000..bb6da80
--- /dev/null
+++ b/c++-qt/src/integer.cpp
@@ -0,0 +1,32 @@
+#include "gats-qt/integer.h"
+
+Gats::Integer::Integer() :
+        iVal( 0 )
+{
+}
+
+Gats::Integer::Integer( int64_t iVal ) :
+        iVal( iVal )
+{
+}
+
+Gats::Integer::~Integer()
+{
+}
+
+void Gats::Integer::write( QIODevice &rOut ) const
+{
+        rOut.write("i", 1 );
+        writePackedInt( rOut, iVal );
+}
+
+void Gats::Integer::read( QIODevice &rIn, char cType )
+{
+        readPackedInt( rIn, iVal );
+}
+/*
+Bu::Formatter &operator<<( Bu::Formatter &f, const Gats::Integer &i )
+{
+        return f << "(int) " << i.getValue();
+}
+*/
diff --git a/c++-qt/src/integer.h b/c++-qt/src/integer.h
new file mode 100644
index 0000000..8695a12
--- /dev/null
+++ b/c++-qt/src/integer.h
@@ -0,0 +1,85 @@
+#ifndef GATS_INTEGER_H
+#define GATS_INTEGER_H
+
+#include "gats-qt/object.h"
+
+#include <stdint.h>
+
+#include <QIODevice>
+
+namespace Gats
+{
+        class Integer : public Gats::Object
+        {
+                Q_OBJECT;
+        public:
+                Integer();
+                Integer( int64_t iVal );
+                virtual ~Integer();
+
+                virtual Type getType() const { return typeInteger; }
+                int64_t getValue() const { return iVal; }
+
+                virtual void write( QIODevice &rOut ) const;
+                virtual void read( QIODevice &rIn, char cType );
+
+                template<typename itype>
+                static void readPackedInt( QIODevice &rStream, itype &rOut )
+                {
+                        int8_t b;
+                        rOut = 0;
+                        bool bNeg;
+
+                        rStream.read( (char *)&b, 1 );
+                        bNeg = ( b&0x40 );
+                        rOut |= (itype(b&0x3F));
+                        int c = 0;
+                        while( (b&0x80) )
+                        {
+                                rStream.read( (char *)&b, 1 );
+                                rOut |= (itype(b&0x7F)) << (6+7*(c++));
+                        }
+                        if( bNeg ) rOut = -rOut;
+                }
+
+                template<typename itype>
+                static void writePackedInt( QIODevice &rStream, itype iIn )
+                {
+                        uint8_t b;
+
+                        if( iIn < 0 )
+                        {
+                                iIn = -iIn;
+                                b = (iIn&0x3F);
+                                if( iIn > b )
+                                        b |= 0x80 | 0x40;
+                                else
+                                        b |= 0x40;
+                        }
+                        else
+                        {
+                                b = (iIn&0x3F);
+                                if( iIn > b )
+                                        b |= 0x80;
+                        }
+                        rStream.write( (const char *)&b, 1 );
+                        iIn = iIn >> 6;
+
+                        while( iIn )
+                        {
+                                b = (iIn&0x7F);
+                                if( iIn > b )
+                                        b |= 0x80;
+                                rStream.write( (const char *)&b, 1 );
+                                iIn = iIn >> 7;
+                        }
+                }
+
+        private:
+                int64_t iVal;
+        };
+};
+
+//Bu::Formatter &operator<<( Bu::Formatter &f, const Gats::Integer &i );
+
+#endif
diff --git a/c++-qt/src/list.cpp b/c++-qt/src/list.cpp
new file mode 100644
index 0000000..59e1770
--- /dev/null
+++ b/c++-qt/src/list.cpp
@@ -0,0 +1,192 @@
+#include "gats-qt/list.h"
+
+#include "gats-qt/string.h"
+#include "gats-qt/integer.h"
+#include "gats-qt/float.h"
+#include "gats-qt/boolean.h"
+#include "gats-qt/dictionary.h"
+
+Gats::List::List()
+{
+}
+
+Gats::List::~List()
+{
+        for( iterator i = begin(); i != end(); i++ )
+        {
+                delete *i;
+        }
+}
+
+void Gats::List::write( QIODevice &rOut ) const
+{
+        rOut.write("l", 1 );
+        for( const_iterator i = begin(); i != end(); i++ )
+        {
+                (*i)->write( rOut );
+        }
+        rOut.write("e", 1 );
+}
+
+void Gats::List::read( QIODevice &rIn, char cType )
+{
+        for(;;)
+        {
+                Gats::Object *pObj = Gats::Object::read( rIn );
+                if( pObj == NULL )
+                        break;
+                append( pObj );
+        }
+}
+
+void Gats::List::append( const char *s )
+{
+        QList<Gats::Object *>::append( new Gats::String( s ) );
+}
+
+void Gats::List::append( const QByteArray &s )
+{
+        QList<Gats::Object *>::append( new Gats::String( s ) );
+}
+
+void Gats::List::append( int32_t i )
+{
+        QList<Gats::Object *>::append( new Gats::Integer( i ) );
+}
+
+void Gats::List::append( int64_t i )
+{
+        QList<Gats::Object *>::append( new Gats::Integer( i ) );
+}
+
+void Gats::List::append( double d )
+{
+        QList<Gats::Object *>::append( new Gats::Float( d ) );
+}
+
+void Gats::List::appendStr( const QByteArray &s )
+{
+        QList<Gats::Object *>::append( new Gats::String( s ) );
+}
+
+void Gats::List::appendInt( int64_t i )
+{
+        QList<Gats::Object *>::append( new Gats::Integer( i ) );
+}
+
+void Gats::List::appendFloat( double d )
+{
+        QList<Gats::Object *>::append( new Gats::Float( d ) );
+}
+
+void Gats::List::appendBool( bool b )
+{
+        QList<Gats::Object *>::append( new Gats::Boolean( b ) );
+}
+
+void Gats::List::appendList( Gats::List *pL )
+{
+        QList<Gats::Object *>::append( pL );
+}
+
+void Gats::List::appendDict( Gats::Dictionary *pD )
+{
+        QList<Gats::Object *>::append( pD );
+}
+
+Gats::List *Gats::List::appendList()
+{
+        Gats::List *pLst = new Gats::List();
+        appendList( pLst );
+        return pLst;
+}
+
+Gats::Dictionary *Gats::List::appendDict()
+{
+        Gats::Dictionary *pDict = new Gats::Dictionary();
+        appendDict( pDict );
+        return pDict;
+}
+
+void Gats::List::prepend( const char *s )
+{
+        QList<Gats::Object *>::prepend( new Gats::String( s ) );
+}
+
+void Gats::List::prepend( const QByteArray &s )
+{
+        QList<Gats::Object *>::prepend( new Gats::String( s ) );
+}
+
+void Gats::List::prepend( int32_t i )
+{
+        QList<Gats::Object *>::prepend( new Gats::Integer( i ) );
+}
+
+void Gats::List::prepend( int64_t i )
+{
+        QList<Gats::Object *>::prepend( new Gats::Integer( i ) );
+}
+
+void Gats::List::prepend( double d )
+{
+        QList<Gats::Object *>::prepend( new Gats::Float( d ) );
+}
+
+void Gats::List::prependStr( const QByteArray &s )
+{
+        QList<Gats::Object *>::prepend( new Gats::String( s ) );
+}
+
+void Gats::List::prependInt( int64_t i )
+{
+        QList<Gats::Object *>::prepend( new Gats::Integer( i ) );
+}
+
+void Gats::List::prependFloat( double d )
+{
+        QList<Gats::Object *>::prepend( new Gats::Float( d ) );
+}
+
+void Gats::List::prependBool( bool b )
+{
+        QList<Gats::Object *>::prepend( new Gats::Boolean( b ) );
+}
+
+void Gats::List::prependList( Gats::List *pL )
+{
+        QList<Gats::Object *>::prepend( pL );
+}
+
+void Gats::List::prependDict( Gats::Dictionary *pD )
+{
+        QList<Gats::Object *>::prepend( pD );
+}
+
+Gats::List *Gats::List::prependList()
+{
+        Gats::List *pLst = new Gats::List();
+        prependList( pLst );
+        return pLst;
+}
+
+Gats::Dictionary *Gats::List::prependDict()
+{
+        Gats::Dictionary *pDict = new Gats::Dictionary();
+        prependDict( pDict );
+        return pDict;
+}
+/*
+Bu::Formatter &operator<<( Bu::Formatter &f, const Gats::List &l )
+{
+        f << "(list) [";
+        f.incIndent();
+        for( Gats::List::const_iterator i = l.begin(); i; i++ )
+        {
+                f << f.nl << **i;
+        }
+        f.decIndent();
+        f << f.nl << "]";
+        return f;
+}
+*/
diff --git a/c++-qt/src/list.h b/c++-qt/src/list.h
new file mode 100644
index 0000000..f712fa5
--- /dev/null
+++ b/c++-qt/src/list.h
@@ -0,0 +1,57 @@
+#ifndef GATS_LIST_H
+#define GATS_LIST_H
+
+#include "gats-qt/object.h"
+#include <QList>
+
+namespace Gats
+{
+        class Dictionary;
+
+        class List : public Gats::Object, public QList<Gats::Object *>
+        {
+                Q_OBJECT;
+        public:
+                List();
+                virtual ~List();
+
+                virtual Type getType() const { return typeList; }
+
+                virtual void write( QIODevice &rOut ) const;
+                virtual void read( QIODevice &rIn, char cType );
+
+                void append( const char *s );
+                void append( const QByteArray &s );
+                void append( int32_t i );
+                void append( int64_t i );
+                void append( double d );
+                using QList<Gats::Object *>::append;
+                void appendStr( const QByteArray &s );
+                void appendInt( int64_t i );
+                void appendFloat( double d );
+                void appendBool( bool b );
+                void appendList( Gats::List *pL );
+                void appendDict( Gats::Dictionary *pD );
+                Gats::List *appendList();
+                Gats::Dictionary *appendDict();
+                
+                void prepend( const char *s );
+                void prepend( const QByteArray &s );
+                void prepend( int32_t i );
+                void prepend( int64_t i );
+                void prepend( double d );
+                using QList<Gats::Object *>::prepend;
+                void prependStr( const QByteArray &s );
+                void prependInt( int64_t i );
+                void prependFloat( double d );
+                void prependBool( bool b );
+                void prependList( Gats::List *pL );
+                void prependDict( Gats::Dictionary *pD );
+                Gats::List *prependList();
+                Gats::Dictionary *prependDict();
+        };
+};
+
+//Bu::Formatter &operator<<( Bu::Formatter &f, const Gats::List &l );
+
+#endif
diff --git a/c++-qt/src/object.cpp b/c++-qt/src/object.cpp
new file mode 100644
index 0000000..3955ced
--- /dev/null
+++ b/c++-qt/src/object.cpp
@@ -0,0 +1,310 @@
+#include "gats-qt/object.h"
+
+#include "gats-qt/integer.h"
+#include "gats-qt/float.h"
+#include "gats-qt/boolean.h"
+#include "gats-qt/string.h"
+#include "gats-qt/list.h"
+#include "gats-qt/dictionary.h"
+
+#include <stdlib.h>
+
+#include <QIODevice>
+
+Gats::Object::Object()
+{
+}
+
+Gats::Object::~Object()
+{
+}
+
+Gats::Object *Gats::Object::read( QIODevice &rIn )
+{
+        char buf;
+        rIn.read( &buf, 1 );
+        Object *pObj = NULL;
+        switch( buf )
+        {
+                case 'i':
+                        pObj = new Gats::Integer();
+                        break;
+
+                case 's':
+                        pObj = new Gats::String();
+                        break;
+
+                case '0':
+                case '1':
+                        pObj = new Gats::Boolean();
+                        break;
+
+                case 'l':
+                        pObj = new Gats::List();
+                        break;
+
+                case 'd':
+                        pObj = new Gats::Dictionary();
+                        break;
+
+                case 'f':  // Normal floats
+                case 'F':  // Special float values
+                        pObj = new Gats::Float();
+                        break;
+
+                case 'e':
+                        return NULL;
+
+                default:
+                        throw "Invalid Gats type discovered: ";
+        }
+
+        pObj->read( rIn, buf );
+
+        return pObj;
+}
+/*
+void Gats::Object::skipWs( QByteArray::const_iterator &i )
+{
+        for(; *i == ' ' || *i == '\t' || *i == '\r' || *i == '\n'; i++ ) { }
+}
+
+QByteArray Gats::Object::token( QByteArray::const_iterator &i )
+{
+        QByteArray sRet;
+        if( *i == '\"' )
+        {
+                for( i++; i && *i != '\"' ; i++ )
+                {
+                        if( *i == '\\' )
+                                i++;
+                        sRet += i;
+                }
+                i++;
+        }
+        else
+        {
+                for(; i && *i != ' ' && *i != '\t' && *i != '\r' && *i != '\n' &&
+                                *i != ',' && *i != ']' && *i != '}' && *i != '[' &&
+                                *i != '{'; i++ )
+                {
+                        sRet += i;
+                }
+        }
+
+        return sRet;
+}
+
+Gats::Object *Gats::Object::strToGats( QByteArray::const_iterator &i )
+{
+        skipWs( i );
+
+        switch( *i )
+        {
+                case '[':
+                        {
+                                Gats::List *pLst = new Gats::List();
+                                i++;
+                                for(;;)
+                                {
+                                        Gats::Object *pObj = strToGats( i );
+                                        if( !pObj )
+                                                break;
+                                        pLst->append( pObj );
+                                        skipWs( i );
+                                        switch( *i )
+                                        {
+                                                case ',':
+                                                        i++;
+                                                        break;
+
+                                                case ']':
+                                                        i++;
+                                                        return pLst;
+
+                                                default:
+                                                        throw "PUT GOOD EXCEPTION HERE";
+                                        }
+                                }
+                        }
+                        break;
+
+                case '{':
+                        {
+                                Gats::Dictionary *pDict = new Gats::Dictionary();
+                                i++;
+                                for(;;)
+                                {
+                                        skipWs( i );
+                                        if( *i != '\"' )
+                                                throw "PUT GOOD EXCEPTION HERE";
+                                        QByteArray sKey = token( i );
+                                        skipWs( i );
+                                        if( *i != ':' )
+                                                throw "PUT GOOD EXCEPTION HERE";
+                                                        "seperated with colons.");
+                                        i++;
+                                        Gats::Object *pObj = strToGats( i );
+                                        if( !pObj )
+                                                throw "PUT GOOD EXCEPTION HERE";
+                                        pDict->insert( sKey, pObj );
+                                        skipWs( i );
+                                        switch( *i )
+                                        {
+                                                case ',':
+                                                        i++;
+                                                        break;
+
+                                                case '}':
+                                                        i++;
+                                                        return pDict;
+
+                                                default:
+                                                        throw "PUT GOOD EXCEPTION HERE";
+                                        }
+                                }
+                        }
+                        break;
+
+                case '\"':
+                        return new Gats::String( token( i ) );
+                        break;
+
+                case '0':
+                case '1':
+                case '2':
+                case '3':
+                case '4':
+                case '5':
+                case '6':
+                case '7':
+                case '8':
+                case '9':
+                case '.':
+                case '+':
+                case '-':
+                        {
+                                QByteArray s = token( i );
+                                int iSize = s.getSize();
+                                if( s[iSize-1] == 'i' )
+                                {
+                                        return new Gats::Integer(
+                                                strtoll( s.getStr(), NULL, 10 )
+                                                );
+                                }
+                                else if( s[iSize-1] == 'f' )
+                                {
+                                        return new Gats::Float(
+                                                strtod( s.getStr(), NULL )
+                                                );
+                                }
+                                else
+                                {
+                                        for( QByteArray::iterator i = s.begin(); i; i++ )
+                                        {
+                                                if( *i == '.' )
+                                                        return new Gats::Float(
+                                                                strtod( s.getStr(), NULL )
+                                                                );
+                                        }
+                                        return new Gats::Integer(
+                                                strtoll( s.getStr(), NULL, 10 )
+                                                );
+                                }
+                        }
+                        break;
+
+                default:
+                        {
+                                QByteArray s = token( i );
+                                int iSize = s.getSize();
+                                // Test for explicit types first
+                                if( iSize > 2 )
+                                {
+                                        if( (s[0] >= '0' && s[0] <= '9') || s[0] == '+' || s[0] == '-' )
+                                        {
+                                        }
+                                        else
+                                        {
+                                                QByteArray st = s.toLower();
+                                                if( st == "true" )
+                                                {
+                                                        return new Gats::Boolean( true );
+                                                }
+                                                else if( st == "false" )
+                                                {
+                                                        return new Gats::Boolean( false );
+                                                }
+                                        }
+                                }
+                        }
+                        break;
+        }
+
+        return NULL;
+}
+
+Gats::Object *Gats::Object::strToGats( const QByteArray &sStr )
+{
+        QByteArray::const_iterator i = sStr.begin();
+
+        return strToGats( i );
+}
+
+Bu::Formatter &operator<<( Bu::Formatter &f, const Gats::Object &obj )
+{
+        switch( obj.getType() )
+        {
+                case Gats::typeDictionary:
+                        return f << dynamic_cast<const Gats::Dictionary &>(obj);
+                
+                case Gats::typeList:
+                        return f << dynamic_cast<const Gats::List &>(obj);
+                
+                case Gats::typeString:
+                        return f << dynamic_cast<const Gats::String &>(obj);
+                
+                case Gats::typeInteger:
+                        return f << dynamic_cast<const Gats::Integer &>(obj);
+                
+                case Gats::typeFloat:
+                        return f << dynamic_cast<const Gats::Float &>(obj);
+                
+                case Gats::typeBoolean:
+                        return f << dynamic_cast<const Gats::Boolean &>(obj);
+
+                default:
+                        return f << "***ERROR: Bad Gats type***";
+        }
+}
+
+Bu::Formatter &operator<<( Bu::Formatter &f, const Gats::Type &t )
+{
+        switch( t )
+        {
+                case Gats::typeDictionary:      return f << "dictionary";
+                case Gats::typeList:            return f << "list";
+                case Gats::typeString:          return f << "string";
+                case Gats::typeInteger:         return f << "integer";
+                case Gats::typeFloat:           return f << "float";
+                case Gats::typeBoolean:         return f << "boolean";
+        }
+
+        return f << "***unknown***";
+}
+*/
+const char *Gats::typeToStr( Gats::Type t )
+{
+        switch( t )
+        {
+                case Gats::typeDictionary:      return "dictionary";
+                case Gats::typeList:            return "list";
+                case Gats::typeString:          return "string";
+                case Gats::typeInteger:         return "integer";
+                case Gats::typeFloat:           return "float";
+                case Gats::typeBoolean:         return "boolean";
+        }
+
+        return "***unknown***";
+}
+
diff --git a/c++-qt/src/object.h b/c++-qt/src/object.h
new file mode 100644
index 0000000..0c08d41
--- /dev/null
+++ b/c++-qt/src/object.h
@@ -0,0 +1,51 @@
+#ifndef GATS_OBJECT_H
+#define GATS_OBJECT_H
+
+#include <QObject>
+#include <QByteArray>
+
+class QIODevice;
+
+namespace Gats
+{
+        enum Type
+        {
+                typeDictionary,
+                typeList,
+                typeString,
+                typeInteger,
+                typeFloat,
+                typeBoolean
+        };
+
+        /**
+         * The baseclass for every type that can be stored in a packet.
+         */
+        class Object : public QObject
+        {
+                Q_OBJECT;
+        public:
+                Object();
+                virtual ~Object();
+
+                virtual Type getType() const =0;
+
+                virtual void write( QIODevice &rOut ) const=0;
+                virtual void read( QIODevice &rIn, char cType )=0;
+
+                static Object *read( QIODevice &rIn );
+//              static Object *strToGats( const  &sStr );
+
+        private:
+//              static Object *strToGats( QByteArray::const_iterator &i );
+//              static QByteArray token( QByteArray::const_iterator &i );
+//              static void skipWs( QByteArray::const_iterator &i );
+        };
+
+        const char *typeToStr( Type t );
+};
+
+//Bu::Formatter &operator<<( Bu::Formatter &f, const Gats::Object &obj );
+//Bu::Formatter &operator<<( Bu::Formatter &f, const Gats::Type &t );
+
+#endif
diff --git a/c++-qt/src/string.cpp b/c++-qt/src/string.cpp
new file mode 100644
index 0000000..0b9e4d8
--- /dev/null
+++ b/c++-qt/src/string.cpp
@@ -0,0 +1,58 @@
+#include "gats-qt/string.h"
+
+#include "gats-qt/integer.h"
+
+Gats::String::String()
+{
+}
+
+Gats::String::String( const char *s ) :
+        QByteArray( s )
+{
+}
+
+Gats::String::String( const char *s, long iLength ) :
+        QByteArray( s, iLength )
+{
+}
+
+Gats::String::String( long iLength ) :
+        QByteArray( iLength, '\0' )
+{
+}
+
+Gats::String::String( const String &s ) :
+        QByteArray( s )
+{
+}
+
+Gats::String::String( const QByteArray &s ) :
+        QByteArray( s )
+{
+}
+
+Gats::String::~String()
+{
+}
+
+void Gats::String::write( QIODevice &rOut ) const
+{
+        rOut.write("s", 1 );
+        uint32_t iSize = size();
+        Gats::Integer::writePackedInt( rOut, iSize );
+        rOut.write( constData(), iSize );
+}
+
+void Gats::String::read( QIODevice &rIn, char cType )
+{
+        uint32_t iSize;
+        Gats::Integer::readPackedInt( rIn, iSize );
+        fill( '\0', iSize );
+        rIn.read( data(), iSize );
+}
+/*
+Bu::Formatter &operator<<( Bu::Formatter &f, const Gats::String &s )
+{
+        return f << "(str) \"" << dynamic_cast<const QByteArray &>(s) << "\"";
+}
+*/
diff --git a/c++-qt/src/string.h b/c++-qt/src/string.h
new file mode 100644
index 0000000..2acd946
--- /dev/null
+++ b/c++-qt/src/string.h
@@ -0,0 +1,32 @@
+#ifndef GATS_STRING_H
+#define GATS_STRING_H
+
+#include "gats-qt/object.h"
+#include <QByteArray>
+
+namespace Gats
+{
+        class String : public Gats::Object, public QByteArray
+        {
+                Q_OBJECT;
+        public:
+                String();
+                String( const char *s );
+                String( const char *s, long iLength );
+                String( long iLength );
+                String( const String &s );
+                String( const QByteArray &s );
+                virtual ~String();
+
+                virtual Type getType() const { return typeString; }
+
+                virtual void write( QIODevice &rOut ) const;
+                virtual void read( QIODevice &rIn, char cType );
+
+        private:
+        };
+};
+
+//Bu::Formatter &operator<<( Bu::Formatter &f, const Gats::String &s );
+
+#endif
diff --git a/c++-qt/src/types.h b/c++-qt/src/types.h
new file mode 100644
index 0000000..1264a9d
--- /dev/null
+++ b/c++-qt/src/types.h
@@ -0,0 +1,7 @@
+#include "gats-qt/object.h"
+#include "gats-qt/boolean.h"
+#include "gats-qt/dictionary.h"
+#include "gats-qt/float.h"
+#include "gats-qt/integer.h"
+#include "gats-qt/list.h"
+#include "gats-qt/string.h"
diff --git a/c++-qt/src/version.h b/c++-qt/src/version.h
new file mode 100644
index 0000000..544dd00
--- /dev/null
+++ b/c++-qt/src/version.h
@@ -0,0 +1,3 @@
+#ifndef LIBGATS_VC_ID
+#define LIBGATS_VC_ID "68:71"
+#endif