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, 349 insertions, 0 deletions

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;
+}
+*/