aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorMike Buland <eichlan@xagasoft.com>2012-03-31 17:34:11 +0000
committerMike Buland <eichlan@xagasoft.com>2012-03-31 17:34:11 +0000
commit82da0238a8171cf8bba6bb1c82d5abba207a10aa (patch)
tree83ff9b022b658e7a056fc85f132937b8bda4c1c3
parent7dd5c386611e31930e7ccfb83cb585df27696881 (diff)
downloadlibgats-82da0238a8171cf8bba6bb1c82d5abba207a10aa.tar.gz
libgats-82da0238a8171cf8bba6bb1c82d5abba207a10aa.tar.bz2
libgats-82da0238a8171cf8bba6bb1c82d5abba207a10aa.tar.xz
libgats-82da0238a8171cf8bba6bb1c82d5abba207a10aa.zip
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.
Diffstat (limited to '')
l---------c++-qt/gats-qt/boolean.h1
l---------c++-qt/gats-qt/dictionary.h1
l---------c++-qt/gats-qt/float.h1
l---------c++-qt/gats-qt/gatsstream.h1
l---------c++-qt/gats-qt/integer.h1
l---------c++-qt/gats-qt/list.h1
l---------c++-qt/gats-qt/object.h1
l---------c++-qt/gats-qt/protocolgats.h1
l---------c++-qt/gats-qt/string.h1
l---------c++-qt/gats-qt/types.h1
l---------c++-qt/gats-qt/version.h1
-rw-r--r--c++-qt/libgats.pro11
-rw-r--r--c++-qt/src/boolean.cpp47
-rw-r--r--c++-qt/src/boolean.h32
-rw-r--r--c++-qt/src/dictionary.cpp349
-rw-r--r--c++-qt/src/dictionary.h68
-rw-r--r--c++-qt/src/float.cpp122
-rw-r--r--c++-qt/src/float.h30
-rw-r--r--c++-qt/src/gatsstream.cpp116
-rw-r--r--c++-qt/src/gatsstream.h57
-rw-r--r--c++-qt/src/integer.cpp32
-rw-r--r--c++-qt/src/integer.h85
-rw-r--r--c++-qt/src/list.cpp192
-rw-r--r--c++-qt/src/list.h57
-rw-r--r--c++-qt/src/object.cpp310
-rw-r--r--c++-qt/src/object.h51
-rw-r--r--c++-qt/src/string.cpp58
-rw-r--r--c++-qt/src/string.h32
-rw-r--r--c++-qt/src/types.h7
-rw-r--r--c++-qt/src/version.h3
30 files changed, 1670 insertions, 0 deletions
diff --git a/c++-qt/gats-qt/boolean.h b/c++-qt/gats-qt/boolean.h
new file mode 120000
index 0000000..27e9ba3
--- /dev/null
+++ b/c++-qt/gats-qt/boolean.h
@@ -0,0 +1 @@
../src/boolean.h \ No newline at end of file
diff --git a/c++-qt/gats-qt/dictionary.h b/c++-qt/gats-qt/dictionary.h
new file mode 120000
index 0000000..cdca1b6
--- /dev/null
+++ b/c++-qt/gats-qt/dictionary.h
@@ -0,0 +1 @@
../src/dictionary.h \ No newline at end of file
diff --git a/c++-qt/gats-qt/float.h b/c++-qt/gats-qt/float.h
new file mode 120000
index 0000000..6d057eb
--- /dev/null
+++ b/c++-qt/gats-qt/float.h
@@ -0,0 +1 @@
../src/float.h \ No newline at end of file
diff --git a/c++-qt/gats-qt/gatsstream.h b/c++-qt/gats-qt/gatsstream.h
new file mode 120000
index 0000000..38d4d0e
--- /dev/null
+++ b/c++-qt/gats-qt/gatsstream.h
@@ -0,0 +1 @@
../src/gatsstream.h \ No newline at end of file
diff --git a/c++-qt/gats-qt/integer.h b/c++-qt/gats-qt/integer.h
new file mode 120000
index 0000000..a2bfb2d
--- /dev/null
+++ b/c++-qt/gats-qt/integer.h
@@ -0,0 +1 @@
../src/integer.h \ No newline at end of file
diff --git a/c++-qt/gats-qt/list.h b/c++-qt/gats-qt/list.h
new file mode 120000
index 0000000..1a01fc0
--- /dev/null
+++ b/c++-qt/gats-qt/list.h
@@ -0,0 +1 @@
../src/list.h \ No newline at end of file
diff --git a/c++-qt/gats-qt/object.h b/c++-qt/gats-qt/object.h
new file mode 120000
index 0000000..04b70ec
--- /dev/null
+++ b/c++-qt/gats-qt/object.h
@@ -0,0 +1 @@
../src/object.h \ No newline at end of file
diff --git a/c++-qt/gats-qt/protocolgats.h b/c++-qt/gats-qt/protocolgats.h
new file mode 120000
index 0000000..034a523
--- /dev/null
+++ b/c++-qt/gats-qt/protocolgats.h
@@ -0,0 +1 @@
../src/protocolgats.h \ No newline at end of file
diff --git a/c++-qt/gats-qt/string.h b/c++-qt/gats-qt/string.h
new file mode 120000
index 0000000..ef7336d
--- /dev/null
+++ b/c++-qt/gats-qt/string.h
@@ -0,0 +1 @@
../src/string.h \ No newline at end of file
diff --git a/c++-qt/gats-qt/types.h b/c++-qt/gats-qt/types.h
new file mode 120000
index 0000000..a21c97e
--- /dev/null
+++ b/c++-qt/gats-qt/types.h
@@ -0,0 +1 @@
../src/types.h \ No newline at end of file
diff --git a/c++-qt/gats-qt/version.h b/c++-qt/gats-qt/version.h
new file mode 120000
index 0000000..0489181
--- /dev/null
+++ b/c++-qt/gats-qt/version.h
@@ -0,0 +1 @@
../src/version.h \ No newline at end of file
diff --git a/c++-qt/libgats.pro b/c++-qt/libgats.pro
new file mode 100644
index 0000000..dea8c9d
--- /dev/null
+++ b/c++-qt/libgats.pro
@@ -0,0 +1,11 @@
1TEMPLATE = lib
2TARGET = gats-qt
3RCC_DIR = tmp/qrc
4UI_DIR = tmp/ui
5MOC_DIR = tmp/moc
6OBJECTS_DIR = tmp/obj
7QMAKE_CXXFLAGS += -ggdb -W -Wall
8
9HEADERS += src/*.h
10SOURCES += src/*.cpp
11
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 @@
1#include "gats-qt/boolean.h"
2
3#include <QIODevice>
4
5Gats::Boolean::Boolean() :
6 bVal( false )
7{
8}
9
10Gats::Boolean::Boolean( bool bVal ) :
11 bVal( bVal )
12{
13}
14
15Gats::Boolean::~Boolean()
16{
17}
18
19void Gats::Boolean::write( QIODevice &rOut ) const
20{
21 if( bVal )
22 {
23 rOut.write("1", 1 );
24 }
25 else
26 {
27 rOut.write("0", 1 );
28 }
29}
30
31void Gats::Boolean::read( QIODevice &rIn, char cType )
32{
33 if( cType == '1' )
34 {
35 bVal = true;
36 }
37 else
38 {
39 bVal = false;
40 }
41}
42/*
43Bu::Formatter &operator<<( Bu::Formatter &f, const Gats::Boolean &b )
44{
45 return f << "(bool) " << b.getValue();
46}
47*/
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 @@
1#ifndef GATS_BOOLEAN_H
2#define GATS_BOOLEAN_H
3
4#include "gats-qt/object.h"
5
6class QIODevice;
7
8namespace Gats
9{
10 class Boolean : public Gats::Object
11 {
12 Q_OBJECT;
13 public:
14 Boolean();
15 Boolean( bool bVal );
16 virtual ~Boolean();
17
18 virtual Type getType() const { return typeBoolean; }
19 bool getValue() const { return bVal; }
20 void setValue( bool b ) { bVal = b; }
21
22 virtual void write( QIODevice &rOut ) const;
23 virtual void read( QIODevice &rIn, char cType );
24
25 private:
26 bool bVal;
27 };
28};
29
30//Bu::Formatter &operator<<( Bu::Formatter &f, const Gats::Boolean &b );
31
32#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 @@
1#include "gats-qt/dictionary.h"
2
3#include "gats-qt/boolean.h"
4#include "gats-qt/integer.h"
5#include "gats-qt/float.h"
6#include "gats-qt/string.h"
7#include "gats-qt/list.h"
8
9Gats::Dictionary::Dictionary()
10{
11}
12
13Gats::Dictionary::~Dictionary()
14{
15 for( iterator i = begin(); i != end(); i++ )
16 {
17 delete *i;
18 }
19}
20
21void Gats::Dictionary::write( QIODevice &rOut ) const
22{
23 rOut.write("d", 1 );
24 for( const_iterator i= begin(); i != end(); i++ )
25 {
26 Gats::String s( i.key() );
27 s.write( rOut );
28 (*i)->write( rOut );
29 }
30 rOut.write("e", 1 );
31}
32
33void Gats::Dictionary::read( QIODevice &rIn, char cType )
34{
35 for(;;)
36 {
37 char cNext;
38 rIn.read( &cNext, 1 );
39 if( cNext == 'e' )
40 break;
41 if( cNext != 's' )
42 throw "PUT GOOD EXCEPTION HERE";
43 Gats::String sKey;
44 sKey.read( rIn, cNext );
45
46 ((QHash<QByteArray, Gats::Object *> *)this)->insert(
47 sKey, Gats::Object::read( rIn )
48 );
49 }
50}
51
52void Gats::Dictionary::insert( const QByteArray &sKey, char i )
53{
54 ((QHash<QByteArray, Gats::Object *> *)this)->insert(
55 sKey, new Gats::Integer( i )
56 );
57}
58
59void Gats::Dictionary::insert( const QByteArray &sKey, unsigned char i )
60{
61 ((QHash<QByteArray, Gats::Object *> *)this)->insert(
62 sKey, new Gats::Integer( i )
63 );
64}
65
66void Gats::Dictionary::insert( const QByteArray &sKey, signed char i )
67{
68 ((QHash<QByteArray, Gats::Object *> *)this)->insert(
69 sKey, new Gats::Integer( i )
70 );
71}
72
73void Gats::Dictionary::insert( const QByteArray &sKey, unsigned short i )
74{
75 ((QHash<QByteArray, Gats::Object *> *)this)->insert(
76 sKey, new Gats::Integer( i )
77 );
78}
79
80void Gats::Dictionary::insert( const QByteArray &sKey, signed short i )
81{
82 ((QHash<QByteArray, Gats::Object *> *)this)->insert(
83 sKey, new Gats::Integer( i )
84 );
85}
86
87void Gats::Dictionary::insert( const QByteArray &sKey, unsigned int i )
88{
89 ((QHash<QByteArray, Gats::Object *> *)this)->insert(
90 sKey, new Gats::Integer( i )
91 );
92}
93
94void Gats::Dictionary::insert( const QByteArray &sKey, signed int i )
95{
96 ((QHash<QByteArray, Gats::Object *> *)this)->insert(
97 sKey, new Gats::Integer( i )
98 );
99}
100
101void Gats::Dictionary::insert( const QByteArray &sKey, unsigned long i )
102{
103 ((QHash<QByteArray, Gats::Object *> *)this)->insert(
104 sKey, new Gats::Integer( i )
105 );
106}
107
108void Gats::Dictionary::insert( const QByteArray &sKey, signed long i )
109{
110 ((QHash<QByteArray, Gats::Object *> *)this)->insert(
111 sKey, new Gats::Integer( i )
112 );
113}
114
115void Gats::Dictionary::insert( const QByteArray &sKey, unsigned long long i )
116{
117 ((QHash<QByteArray, Gats::Object *> *)this)->insert(
118 sKey, new Gats::Integer( i )
119 );
120}
121
122void Gats::Dictionary::insert( const QByteArray &sKey, signed long long i )
123{
124 ((QHash<QByteArray, Gats::Object *> *)this)->insert(
125 sKey, new Gats::Integer( i )
126 );
127}
128/*
129void Gats::Dictionary::insert( const QByteArray &sKey, bool b )
130{
131 QHash<QByteArray, Gats::Object *>::insert(
132 sKey, new Gats::Boolean( b )
133 );
134}*/
135
136void Gats::Dictionary::insert( const QByteArray &sKey, float d )
137{
138 QHash<QByteArray, Gats::Object *>::insert(
139 sKey, new Gats::Float( d )
140 );
141}
142
143void Gats::Dictionary::insert( const QByteArray &sKey, double d )
144{
145 QHash<QByteArray, Gats::Object *>::insert(
146 sKey, new Gats::Float( d )
147 );
148}
149
150void Gats::Dictionary::insert( const QByteArray &sKey, const char *s )
151{
152 QHash<QByteArray, Gats::Object *>::insert(
153 sKey, new Gats::String( s )
154 );
155}
156
157void Gats::Dictionary::insert( const QByteArray &sKey, const QByteArray &s )
158{
159 QHash<QByteArray, Gats::Object *>::insert(
160 sKey, new Gats::String( s )
161 );
162}
163
164void Gats::Dictionary::insertBool( const QByteArray &sKey, bool b )
165{
166 QHash<QByteArray, Gats::Object *>::insert(
167 sKey, new Gats::Boolean( b )
168 );
169}
170
171void Gats::Dictionary::insertInt( const QByteArray &sKey, int64_t i )
172{
173 QHash<QByteArray, Gats::Object *>::insert(
174 sKey, new Gats::Integer( i )
175 );
176}
177
178void Gats::Dictionary::insertFloat( const QByteArray &sKey, double d )
179{
180 QHash<QByteArray, Gats::Object *>::insert(
181 sKey, new Gats::Float( d )
182 );
183}
184
185void Gats::Dictionary::insertStr( const QByteArray &sKey, const QByteArray &s )
186{
187 QHash<QByteArray, Gats::Object *>::insert(
188 sKey, new Gats::String( s )
189 );
190}
191
192void Gats::Dictionary::insertList( const QByteArray &sKey, Gats::List *pL )
193{
194 QHash<QByteArray, Gats::Object *>::insert(
195 sKey, pL
196 );
197}
198
199void Gats::Dictionary::insertDict( const QByteArray &sKey,
200 Gats::Dictionary *pD )
201{
202 QHash<QByteArray, Gats::Object *>::insert(
203 sKey, pD
204 );
205}
206
207Gats::List *Gats::Dictionary::insertList( const QByteArray &sKey )
208{
209 Gats::List *pLst = new Gats::List();
210 insertList( sKey, pLst );
211 return pLst;
212}
213
214Gats::Dictionary *Gats::Dictionary::insertDict( const QByteArray &sKey )
215{
216 Gats::Dictionary *pDict = new Gats::Dictionary();
217 insertDict( sKey, pDict );
218 return pDict;
219}
220
221bool Gats::Dictionary::valueBool( const QByteArray &sKey )
222{
223 Gats::Boolean *pOb = dynamic_cast<Gats::Boolean *>( value( sKey ) );
224 if( !pOb )
225 throw "PUT GOOD EXCEPTION HERE";
226
227 return pOb->getValue();
228}
229
230int64_t Gats::Dictionary::valueInt( const QByteArray &sKey )
231{
232 Gats::Integer *pOb = dynamic_cast<Gats::Integer *>( value( sKey ) );
233 if( !pOb )
234 throw "PUT GOOD EXCEPTION HERE";
235
236 return pOb->getValue();
237}
238
239double Gats::Dictionary::valueFloat( const QByteArray &sKey )
240{
241 Gats::Float *pOb = dynamic_cast<Gats::Float *>( value( sKey ) );
242 if( !pOb )
243 throw "PUT GOOD EXCEPTION HERE";
244
245 return pOb->getValue();
246}
247
248QByteArray Gats::Dictionary::valueStr( const QByteArray &sKey )
249{
250 Gats::String *pOb = dynamic_cast<Gats::String *>( value( sKey ) );
251 if( !pOb )
252 throw "PUT GOOD EXCEPTION HERE";
253
254 return *pOb;
255}
256
257Gats::List *Gats::Dictionary::valueList( const QByteArray &sKey )
258{
259 Gats::List *pOb = dynamic_cast<Gats::List *>( value( sKey ) );
260 if( !pOb )
261 throw "PUT GOOD EXCEPTION HERE";
262
263 return pOb;
264}
265
266Gats::Dictionary *Gats::Dictionary::valueDict( const QByteArray &sKey )
267{
268 Gats::Dictionary *pOb = dynamic_cast<Gats::Dictionary *>( value( sKey ) );
269 if( !pOb )
270 throw "PUT GOOD EXCEPTION HERE";
271
272 return pOb;
273}
274
275bool Gats::Dictionary::valueBool( const QByteArray &sKey ) const
276{
277 Gats::Boolean *pOb = dynamic_cast<Gats::Boolean *>( value( sKey ) );
278 if( !pOb )
279 throw "PUT GOOD EXCEPTION HERE";
280
281 return pOb->getValue();
282}
283
284int64_t Gats::Dictionary::valueInt( const QByteArray &sKey ) const
285{
286 Gats::Integer *pOb = dynamic_cast<Gats::Integer *>( value( sKey ) );
287 if( !pOb )
288 throw "PUT GOOD EXCEPTION HERE";
289
290 return pOb->getValue();
291}
292
293double Gats::Dictionary::valueFloat( const QByteArray &sKey ) const
294{
295 Gats::Float *pOb = dynamic_cast<Gats::Float *>( value( sKey ) );
296 if( !pOb )
297 throw "PUT GOOD EXCEPTION HERE";
298
299 return pOb->getValue();
300}
301
302QByteArray Gats::Dictionary::valueStr( const QByteArray &sKey ) const
303{
304 Gats::String *pOb = dynamic_cast<Gats::String *>( value( sKey ) );
305 if( !pOb )
306 throw "PUT GOOD EXCEPTION HERE";
307
308 return *pOb;
309}
310
311Gats::List *Gats::Dictionary::valueList( const QByteArray &sKey ) const
312{
313 Gats::List *pOb = dynamic_cast<Gats::List *>( value( sKey ) );
314 if( !pOb )
315 throw "PUT GOOD EXCEPTION HERE";
316
317 return pOb;
318}
319
320Gats::Dictionary *Gats::Dictionary::valueDict( const QByteArray &sKey ) const
321{
322 Gats::Dictionary *pOb = dynamic_cast<Gats::Dictionary *>( value( sKey ) );
323 if( !pOb )
324 throw "PUT GOOD EXCEPTION HERE";
325
326 return pOb;
327}
328/*
329Bu::Formatter &operator<<( Bu::Formatter &f, const Gats::Dictionary &d )
330{
331 f << "(dict) {";
332 f.incIndent();
333 int iMax = 0;
334 for( Gats::Dictionary::const_iterator i = d.begin(); i; i++ )
335 {
336 if( i.valueKey().valueSize() > iMax )
337 iMax = i.valueKey().valueSize();
338 }
339 iMax += 2;
340 for( Gats::Dictionary::const_iterator i = d.begin(); i; i++ )
341 {
342 f << f.nl << Bu::Fmt( iMax ) << i.valueKey() + ": " << *i.getValue();
343 }
344 f.decIndent();
345 f << f.nl << "}";
346
347 return f;
348}
349*/
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 @@
1#ifndef GATS_DICTIONARY_H
2#define GATS_DICTIONARY_H
3
4#include "gats-qt/object.h"
5#include "gats-qt/string.h"
6#include <QHash>
7
8namespace Gats
9{
10 class List;
11
12 class Dictionary : public Gats::Object,
13 public QHash<QByteArray, Gats::Object *>
14 {
15 Q_OBJECT;
16 public:
17 Dictionary();
18 virtual ~Dictionary();
19
20 virtual Type getType() const { return typeDictionary; }
21 virtual void write( QIODevice &rOut ) const;
22 virtual void read( QIODevice &rIn, char cType );
23
24 void insert( const QByteArray &sKey, const char *s );
25 void insert( const QByteArray &sKey, const QByteArray &s );
26 void insert( const QByteArray &sKey, char i );
27 void insert( const QByteArray &sKey, unsigned char i );
28 void insert( const QByteArray &sKey, signed char i );
29 void insert( const QByteArray &sKey, unsigned short i );
30 void insert( const QByteArray &sKey, signed short i );
31 void insert( const QByteArray &sKey, unsigned int i );
32 void insert( const QByteArray &sKey, signed int i );
33 void insert( const QByteArray &sKey, unsigned long i );
34 void insert( const QByteArray &sKey, signed long i );
35 void insert( const QByteArray &sKey, unsigned long long i );
36 void insert( const QByteArray &sKey, signed long long i );
37 //void insert( const QByteArray &sKey, bool b );
38 void insert( const QByteArray &sKey, float d );
39 void insert( const QByteArray &sKey, double d );
40 using QHash<QByteArray, Gats::Object *>::insert;
41 void insertBool( const QByteArray &sKey, bool b );
42 void insertInt( const QByteArray &sKey, int64_t i );
43 void insertFloat( const QByteArray &sKey, double d );
44 void insertStr( const QByteArray &sKey, const QByteArray &s );
45 void insertList( const QByteArray &sKey, Gats::List *pL );
46 void insertDict( const QByteArray &sKey, Gats::Dictionary *pD );
47 Gats::List *insertList( const QByteArray &sKey );
48 Gats::Dictionary *insertDict( const QByteArray &sKey );
49
50 bool valueBool( const QByteArray &sKey );
51 int64_t valueInt( const QByteArray &sKey );
52 double valueFloat( const QByteArray &sKey );
53 QByteArray valueStr( const QByteArray &sKey );
54 Gats::List *valueList( const QByteArray &sKey );
55 Gats::Dictionary *valueDict( const QByteArray &sKey );
56
57 bool valueBool( const QByteArray &sKey ) const;
58 int64_t valueInt( const QByteArray &sKey ) const;
59 double valueFloat( const QByteArray &sKey ) const;
60 QByteArray valueStr( const QByteArray &sKey ) const;
61 Gats::List *valueList( const QByteArray &sKey ) const;
62 Gats::Dictionary *valueDict( const QByteArray &sKey ) const;
63 };
64};
65
66//Bu::Formatter &operator<<( Bu::Formatter &f, const Gats::Dictionary &d );
67
68#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 @@
1#include "gats-qt/float.h"
2#include "gats-qt/integer.h"
3
4#include <math.h>
5
6Gats::Float::Float() :
7 fVal( 0.0 )
8{
9}
10
11Gats::Float::Float( double f ) :
12 fVal( f )
13{
14}
15
16Gats::Float::~Float()
17{
18}
19
20void Gats::Float::write( QIODevice &rOut ) const
21{
22 if( fVal == 0.0 )
23 {
24 if( signbit( fVal ) )
25 rOut.write("FZ", 2 );
26 else
27 rOut.write("Fz", 2 );
28 }
29 else if( !isfinite( fVal ) )
30 {
31 if( isnan( fVal ) )
32 {
33 if( signbit( fVal ) )
34 rOut.write("FN", 2 );
35 else
36 rOut.write("Fn", 2 );
37 }
38 else
39 {
40 if( signbit( fVal ) )
41 rOut.write("FI", 2 );
42 else
43 rOut.write("Fi", 2 );
44 }
45 }
46 else
47 {
48 rOut.write("f", 1 );
49 double d = fVal;
50 bool bNeg = false;
51 int64_t iScale=0;
52 if( signbit( d ) )
53 {
54 bNeg = true;
55 d = -d;
56 }
57
58 iScale = log( d ) / 0x1.62e42fefa39efp+2; // log( 256.0 )
59 if( iScale < 0 ) iScale--;
60 d /= pow( 256.0, iScale );
61
62 QByteArray s;
63 s += (uint8_t)(d);
64 d -= (int)d;
65 for( int j = 0; j < 150 && d; j++ )
66 {
67 d = d*256.0;
68 s += (uint8_t)d;
69 d -= (int)d;
70 }
71 Gats::Integer::writePackedInt( rOut, bNeg?-s.size():s.size() );
72 rOut.write( s.constData(), s.size() );
73 Gats::Integer::writePackedInt( rOut, iScale );
74 }
75}
76
77void Gats::Float::read( QIODevice &rIn, char cType )
78{
79 if( cType == 'F' )
80 {
81 char buf;
82 rIn.read( &buf, 1 );
83 switch( buf )
84 {
85 case 'N': fVal = -NAN; break;
86 case 'n': fVal = NAN; break;
87 case 'I': fVal = -INFINITY; break;
88 case 'i': fVal = INFINITY; break;
89 case 'Z': fVal = -0.0; break;
90 case 'z': fVal = 0.0; break;
91 }
92 }
93 else if( cType == 'f' )
94 {
95 int64_t iStr;
96 Gats::Integer::readPackedInt( rIn, iStr );
97 bool bNeg = false;
98 if( iStr < 0 )
99 {
100 bNeg = true;
101 iStr = -iStr;
102 }
103 QByteArray s( iStr, '\0' );
104 rIn.read( s.data(), iStr );
105 fVal = 0.0;
106 for( int j = iStr-1; j > 0; j-- )
107 {
108 fVal = (fVal+(uint8_t)s[j])*0x1p-8;
109 }
110 fVal += (uint8_t)s[0];
111 int64_t iScale;
112 Gats::Integer::readPackedInt( rIn, iScale );
113 fVal *= pow( 256.0, iScale );
114 if( bNeg ) fVal = -fVal;
115 }
116}
117/*
118Bu::Formatter &operator<<( Bu::Formatter &f, const Gats::Float &flt )
119{
120 return f << "(float) " << flt.getValue();
121}*/
122
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 @@
1#ifndef GATS_FLOAT_H
2#define GATS_FLOAT_H
3
4#include "gats-qt/object.h"
5
6namespace Gats
7{
8 class Float : public Gats::Object
9 {
10 Q_OBJECT;
11 public:
12 Float();
13 Float( double f );
14 virtual ~Float();
15
16 virtual Type getType() const { return typeFloat; }
17 double getValue() const { return fVal; }
18
19 virtual void write( QIODevice &rOut ) const;
20 virtual void read( QIODevice &rIn, char cType );
21
22 private:
23 double fVal;
24 mutable QByteArray sWriteCache;
25 };
26}
27
28//Bu::Formatter &operator<<( Bu::Formatter &f, const Gats::Float &flt );
29
30#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 @@
1#include "gats-qt/gatsstream.h"
2#include "gats-qt/object.h"
3
4#ifdef WIN32
5#include <winsock2.h>
6#else
7#include <arpa/inet.h>
8#endif
9
10#include <QBuffer>
11
12Gats::GatsStream::GatsStream( QIODevice &rStream ) :
13 rStream( rStream )
14{
15}
16
17Gats::GatsStream::~GatsStream()
18{
19}
20
21Gats::Object *Gats::GatsStream::readObject()
22{
23 char buf[1500];
24
25 do
26 {
27 if( qbRead.size() < 5 )
28 {
29 int iRead = rStream.read( buf, 5-qbRead.size() );
30 qbRead.append( buf, iRead );
31
32 if( qbRead.size() < 5 )
33 return NULL;
34 }
35 } while( !skipReadNulls() );
36
37 uint8_t uVer;
38 uVer = qbRead[0];
39
40 int32_t iSize;
41 memcpy( &iSize, qbRead.constData()+1, 4 );
42 iSize = ntohl( iSize );
43 while( qbRead.size() < iSize )
44 {
45 int32_t iRead = iSize - qbRead.size();
46 if( iRead > 1500 )
47 iRead = 1500;
48 int32_t iReal = rStream.read( buf, iRead );
49 qbRead.append( buf, iReal );
50 if( iReal < iRead )
51 {
52 return NULL;
53 }
54 }
55
56 if( qbRead.size() < iSize )
57 {
58 return NULL;
59 }
60
61 QBuffer rTmp( &qbRead );
62 rTmp.open( QIODevice::ReadOnly );
63 rTmp.seek( 5 );
64 Gats::Object *pObj = Gats::Object::read( rTmp );
65
66 return pObj;
67}
68
69void Gats::GatsStream::writeObject( Gats::Object *pObject )
70{
71 QIODevice *pTmp;
72 if( rStream.isSequential() )
73 {
74 pTmp = new QBuffer();
75 pTmp->open( QIODevice::WriteOnly );
76 }
77 else
78 {
79 pTmp = &rStream;
80 }
81
82 uint8_t uBuf = 1;
83 uint32_t iSize = 0;
84 pTmp->write( (const char *)&uBuf, 1 );
85 uint64_t iSizePos = pTmp->pos();
86 pTmp->write( (const char *)&iSize, 4 );
87 pObject->write( *pTmp );
88 iSize = htonl( pTmp->pos() );
89 pTmp->seek( iSizePos );
90 pTmp->write( (const char *)&iSize, 4 );
91 pTmp->close();
92
93 if( rStream.isSequential() )
94 {
95 rStream.write( ((QBuffer *)pTmp)->data() );
96 delete pTmp;
97 }
98}
99
100bool Gats::GatsStream::skipReadNulls()
101{
102 bool bHaveSeeked = false;
103 for(;;)
104 {
105 if( qbRead.size() == 0 )
106 return false;
107 if( qbRead.at(0) != 0 )
108 return !bHaveSeeked; //true;
109 else
110 {
111 qbRead.remove( 0, 1 );
112 bHaveSeeked = true;
113 }
114 }
115}
116
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 @@
1#ifndef GATS_STREAM_H
2#define GATS_STREAM_H
3
4#include <QIODevice>
5#include <QByteArray>
6
7namespace Gats
8{
9 class Object;
10
11 class GatsStream : public QObject
12 {
13 Q_OBJECT;
14 public:
15 GatsStream( QIODevice &rStream );
16 virtual ~GatsStream();
17
18 /**
19 * Read an object packet from the assosiated stream. This will make
20 * every effort to only read exactly enough data to describe one packet,
21 * in case you want to do other things with your stream. It will
22 * automatically skip NULL byte spacing between packets, which makes
23 * a convinient padding method for encrypted data streams. Since
24 * sizing information is available in the packet header exact amounts
25 * of data can be read, however this function doesn't assume that it
26 * can read the entire object in one operation. If it fails to read
27 * a complete packet in one call, it will keep the data it's read so
28 * far buffered and return NULL, ready for another attempt. You can
29 * use the function hasReadBuffer() to deterimne if readObject()
30 * has read part of an object packet or not. If readObject returns
31 * non-null then hasReadBuffer should return false on it's next call.
32 */
33 Gats::Object *readObject();
34
35 /**
36 * Write an object
37 */
38 void writeObject( Gats::Object *pObject );
39
40 /**
41 * Tells you if there is data still in the read buffer, i.e. that a
42 * packet is part way through being read. If readObject has returned
43 * non-null in the most recent call, this should always be false.
44 */
45 bool hasReadBuffer() { return qbRead.size() > 0; }
46 int getReadBufferSize() { return qbRead.size(); }
47
48 private:
49 bool skipReadNulls();
50
51 private:
52 QIODevice &rStream;
53 QByteArray qbRead;
54 };
55};
56
57#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 @@
1#include "gats-qt/integer.h"
2
3Gats::Integer::Integer() :
4 iVal( 0 )
5{
6}
7
8Gats::Integer::Integer( int64_t iVal ) :
9 iVal( iVal )
10{
11}
12
13Gats::Integer::~Integer()
14{
15}
16
17void Gats::Integer::write( QIODevice &rOut ) const
18{
19 rOut.write("i", 1 );
20 writePackedInt( rOut, iVal );
21}
22
23void Gats::Integer::read( QIODevice &rIn, char cType )
24{
25 readPackedInt( rIn, iVal );
26}
27/*
28Bu::Formatter &operator<<( Bu::Formatter &f, const Gats::Integer &i )
29{
30 return f << "(int) " << i.getValue();
31}
32*/
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 @@
1#ifndef GATS_INTEGER_H
2#define GATS_INTEGER_H
3
4#include "gats-qt/object.h"
5
6#include <stdint.h>
7
8#include <QIODevice>
9
10namespace Gats
11{
12 class Integer : public Gats::Object
13 {
14 Q_OBJECT;
15 public:
16 Integer();
17 Integer( int64_t iVal );
18 virtual ~Integer();
19
20 virtual Type getType() const { return typeInteger; }
21 int64_t getValue() const { return iVal; }
22
23 virtual void write( QIODevice &rOut ) const;
24 virtual void read( QIODevice &rIn, char cType );
25
26 template<typename itype>
27 static void readPackedInt( QIODevice &rStream, itype &rOut )
28 {
29 int8_t b;
30 rOut = 0;
31 bool bNeg;
32
33 rStream.read( (char *)&b, 1 );
34 bNeg = ( b&0x40 );
35 rOut |= (itype(b&0x3F));
36 int c = 0;
37 while( (b&0x80) )
38 {
39 rStream.read( (char *)&b, 1 );
40 rOut |= (itype(b&0x7F)) << (6+7*(c++));
41 }
42 if( bNeg ) rOut = -rOut;
43 }
44
45 template<typename itype>
46 static void writePackedInt( QIODevice &rStream, itype iIn )
47 {
48 uint8_t b;
49
50 if( iIn < 0 )
51 {
52 iIn = -iIn;
53 b = (iIn&0x3F);
54 if( iIn > b )
55 b |= 0x80 | 0x40;
56 else
57 b |= 0x40;
58 }
59 else
60 {
61 b = (iIn&0x3F);
62 if( iIn > b )
63 b |= 0x80;
64 }
65 rStream.write( (const char *)&b, 1 );
66 iIn = iIn >> 6;
67
68 while( iIn )
69 {
70 b = (iIn&0x7F);
71 if( iIn > b )
72 b |= 0x80;
73 rStream.write( (const char *)&b, 1 );
74 iIn = iIn >> 7;
75 }
76 }
77
78 private:
79 int64_t iVal;
80 };
81};
82
83//Bu::Formatter &operator<<( Bu::Formatter &f, const Gats::Integer &i );
84
85#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 @@
1#include "gats-qt/list.h"
2
3#include "gats-qt/string.h"
4#include "gats-qt/integer.h"
5#include "gats-qt/float.h"
6#include "gats-qt/boolean.h"
7#include "gats-qt/dictionary.h"
8
9Gats::List::List()
10{
11}
12
13Gats::List::~List()
14{
15 for( iterator i = begin(); i != end(); i++ )
16 {
17 delete *i;
18 }
19}
20
21void Gats::List::write( QIODevice &rOut ) const
22{
23 rOut.write("l", 1 );
24 for( const_iterator i = begin(); i != end(); i++ )
25 {
26 (*i)->write( rOut );
27 }
28 rOut.write("e", 1 );
29}
30
31void Gats::List::read( QIODevice &rIn, char cType )
32{
33 for(;;)
34 {
35 Gats::Object *pObj = Gats::Object::read( rIn );
36 if( pObj == NULL )
37 break;
38 append( pObj );
39 }
40}
41
42void Gats::List::append( const char *s )
43{
44 QList<Gats::Object *>::append( new Gats::String( s ) );
45}
46
47void Gats::List::append( const QByteArray &s )
48{
49 QList<Gats::Object *>::append( new Gats::String( s ) );
50}
51
52void Gats::List::append( int32_t i )
53{
54 QList<Gats::Object *>::append( new Gats::Integer( i ) );
55}
56
57void Gats::List::append( int64_t i )
58{
59 QList<Gats::Object *>::append( new Gats::Integer( i ) );
60}
61
62void Gats::List::append( double d )
63{
64 QList<Gats::Object *>::append( new Gats::Float( d ) );
65}
66
67void Gats::List::appendStr( const QByteArray &s )
68{
69 QList<Gats::Object *>::append( new Gats::String( s ) );
70}
71
72void Gats::List::appendInt( int64_t i )
73{
74 QList<Gats::Object *>::append( new Gats::Integer( i ) );
75}
76
77void Gats::List::appendFloat( double d )
78{
79 QList<Gats::Object *>::append( new Gats::Float( d ) );
80}
81
82void Gats::List::appendBool( bool b )
83{
84 QList<Gats::Object *>::append( new Gats::Boolean( b ) );
85}
86
87void Gats::List::appendList( Gats::List *pL )
88{
89 QList<Gats::Object *>::append( pL );
90}
91
92void Gats::List::appendDict( Gats::Dictionary *pD )
93{
94 QList<Gats::Object *>::append( pD );
95}
96
97Gats::List *Gats::List::appendList()
98{
99 Gats::List *pLst = new Gats::List();
100 appendList( pLst );
101 return pLst;
102}
103
104Gats::Dictionary *Gats::List::appendDict()
105{
106 Gats::Dictionary *pDict = new Gats::Dictionary();
107 appendDict( pDict );
108 return pDict;
109}
110
111void Gats::List::prepend( const char *s )
112{
113 QList<Gats::Object *>::prepend( new Gats::String( s ) );
114}
115
116void Gats::List::prepend( const QByteArray &s )
117{
118 QList<Gats::Object *>::prepend( new Gats::String( s ) );
119}
120
121void Gats::List::prepend( int32_t i )
122{
123 QList<Gats::Object *>::prepend( new Gats::Integer( i ) );
124}
125
126void Gats::List::prepend( int64_t i )
127{
128 QList<Gats::Object *>::prepend( new Gats::Integer( i ) );
129}
130
131void Gats::List::prepend( double d )
132{
133 QList<Gats::Object *>::prepend( new Gats::Float( d ) );
134}
135
136void Gats::List::prependStr( const QByteArray &s )
137{
138 QList<Gats::Object *>::prepend( new Gats::String( s ) );
139}
140
141void Gats::List::prependInt( int64_t i )
142{
143 QList<Gats::Object *>::prepend( new Gats::Integer( i ) );
144}
145
146void Gats::List::prependFloat( double d )
147{
148 QList<Gats::Object *>::prepend( new Gats::Float( d ) );
149}
150
151void Gats::List::prependBool( bool b )
152{
153 QList<Gats::Object *>::prepend( new Gats::Boolean( b ) );
154}
155
156void Gats::List::prependList( Gats::List *pL )
157{
158 QList<Gats::Object *>::prepend( pL );
159}
160
161void Gats::List::prependDict( Gats::Dictionary *pD )
162{
163 QList<Gats::Object *>::prepend( pD );
164}
165
166Gats::List *Gats::List::prependList()
167{
168 Gats::List *pLst = new Gats::List();
169 prependList( pLst );
170 return pLst;
171}
172
173Gats::Dictionary *Gats::List::prependDict()
174{
175 Gats::Dictionary *pDict = new Gats::Dictionary();
176 prependDict( pDict );
177 return pDict;
178}
179/*
180Bu::Formatter &operator<<( Bu::Formatter &f, const Gats::List &l )
181{
182 f << "(list) [";
183 f.incIndent();
184 for( Gats::List::const_iterator i = l.begin(); i; i++ )
185 {
186 f << f.nl << **i;
187 }
188 f.decIndent();
189 f << f.nl << "]";
190 return f;
191}
192*/
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 @@
1#ifndef GATS_LIST_H
2#define GATS_LIST_H
3
4#include "gats-qt/object.h"
5#include <QList>
6
7namespace Gats
8{
9 class Dictionary;
10
11 class List : public Gats::Object, public QList<Gats::Object *>
12 {
13 Q_OBJECT;
14 public:
15 List();
16 virtual ~List();
17
18 virtual Type getType() const { return typeList; }
19
20 virtual void write( QIODevice &rOut ) const;
21 virtual void read( QIODevice &rIn, char cType );
22
23 void append( const char *s );
24 void append( const QByteArray &s );
25 void append( int32_t i );
26 void append( int64_t i );
27 void append( double d );
28 using QList<Gats::Object *>::append;
29 void appendStr( const QByteArray &s );
30 void appendInt( int64_t i );
31 void appendFloat( double d );
32 void appendBool( bool b );
33 void appendList( Gats::List *pL );
34 void appendDict( Gats::Dictionary *pD );
35 Gats::List *appendList();
36 Gats::Dictionary *appendDict();
37
38 void prepend( const char *s );
39 void prepend( const QByteArray &s );
40 void prepend( int32_t i );
41 void prepend( int64_t i );
42 void prepend( double d );
43 using QList<Gats::Object *>::prepend;
44 void prependStr( const QByteArray &s );
45 void prependInt( int64_t i );
46 void prependFloat( double d );
47 void prependBool( bool b );
48 void prependList( Gats::List *pL );
49 void prependDict( Gats::Dictionary *pD );
50 Gats::List *prependList();
51 Gats::Dictionary *prependDict();
52 };
53};
54
55//Bu::Formatter &operator<<( Bu::Formatter &f, const Gats::List &l );
56
57#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 @@
1#include "gats-qt/object.h"
2
3#include "gats-qt/integer.h"
4#include "gats-qt/float.h"
5#include "gats-qt/boolean.h"
6#include "gats-qt/string.h"
7#include "gats-qt/list.h"
8#include "gats-qt/dictionary.h"
9
10#include <stdlib.h>
11
12#include <QIODevice>
13
14Gats::Object::Object()
15{
16}
17
18Gats::Object::~Object()
19{
20}
21
22Gats::Object *Gats::Object::read( QIODevice &rIn )
23{
24 char buf;
25 rIn.read( &buf, 1 );
26 Object *pObj = NULL;
27 switch( buf )
28 {
29 case 'i':
30 pObj = new Gats::Integer();
31 break;
32
33 case 's':
34 pObj = new Gats::String();
35 break;
36
37 case '0':
38 case '1':
39 pObj = new Gats::Boolean();
40 break;
41
42 case 'l':
43 pObj = new Gats::List();
44 break;
45
46 case 'd':
47 pObj = new Gats::Dictionary();
48 break;
49
50 case 'f': // Normal floats
51 case 'F': // Special float values
52 pObj = new Gats::Float();
53 break;
54
55 case 'e':
56 return NULL;
57
58 default:
59 throw "Invalid Gats type discovered: ";
60 }
61
62 pObj->read( rIn, buf );
63
64 return pObj;
65}
66/*
67void Gats::Object::skipWs( QByteArray::const_iterator &i )
68{
69 for(; *i == ' ' || *i == '\t' || *i == '\r' || *i == '\n'; i++ ) { }
70}
71
72QByteArray Gats::Object::token( QByteArray::const_iterator &i )
73{
74 QByteArray sRet;
75 if( *i == '\"' )
76 {
77 for( i++; i && *i != '\"' ; i++ )
78 {
79 if( *i == '\\' )
80 i++;
81 sRet += i;
82 }
83 i++;
84 }
85 else
86 {
87 for(; i && *i != ' ' && *i != '\t' && *i != '\r' && *i != '\n' &&
88 *i != ',' && *i != ']' && *i != '}' && *i != '[' &&
89 *i != '{'; i++ )
90 {
91 sRet += i;
92 }
93 }
94
95 return sRet;
96}
97
98Gats::Object *Gats::Object::strToGats( QByteArray::const_iterator &i )
99{
100 skipWs( i );
101
102 switch( *i )
103 {
104 case '[':
105 {
106 Gats::List *pLst = new Gats::List();
107 i++;
108 for(;;)
109 {
110 Gats::Object *pObj = strToGats( i );
111 if( !pObj )
112 break;
113 pLst->append( pObj );
114 skipWs( i );
115 switch( *i )
116 {
117 case ',':
118 i++;
119 break;
120
121 case ']':
122 i++;
123 return pLst;
124
125 default:
126 throw "PUT GOOD EXCEPTION HERE";
127 }
128 }
129 }
130 break;
131
132 case '{':
133 {
134 Gats::Dictionary *pDict = new Gats::Dictionary();
135 i++;
136 for(;;)
137 {
138 skipWs( i );
139 if( *i != '\"' )
140 throw "PUT GOOD EXCEPTION HERE";
141 QByteArray sKey = token( i );
142 skipWs( i );
143 if( *i != ':' )
144 throw "PUT GOOD EXCEPTION HERE";
145 "seperated with colons.");
146 i++;
147 Gats::Object *pObj = strToGats( i );
148 if( !pObj )
149 throw "PUT GOOD EXCEPTION HERE";
150 pDict->insert( sKey, pObj );
151 skipWs( i );
152 switch( *i )
153 {
154 case ',':
155 i++;
156 break;
157
158 case '}':
159 i++;
160 return pDict;
161
162 default:
163 throw "PUT GOOD EXCEPTION HERE";
164 }
165 }
166 }
167 break;
168
169 case '\"':
170 return new Gats::String( token( i ) );
171 break;
172
173 case '0':
174 case '1':
175 case '2':
176 case '3':
177 case '4':
178 case '5':
179 case '6':
180 case '7':
181 case '8':
182 case '9':
183 case '.':
184 case '+':
185 case '-':
186 {
187 QByteArray s = token( i );
188 int iSize = s.getSize();
189 if( s[iSize-1] == 'i' )
190 {
191 return new Gats::Integer(
192 strtoll( s.getStr(), NULL, 10 )
193 );
194 }
195 else if( s[iSize-1] == 'f' )
196 {
197 return new Gats::Float(
198 strtod( s.getStr(), NULL )
199 );
200 }
201 else
202 {
203 for( QByteArray::iterator i = s.begin(); i; i++ )
204 {
205 if( *i == '.' )
206 return new Gats::Float(
207 strtod( s.getStr(), NULL )
208 );
209 }
210 return new Gats::Integer(
211 strtoll( s.getStr(), NULL, 10 )
212 );
213 }
214 }
215 break;
216
217 default:
218 {
219 QByteArray s = token( i );
220 int iSize = s.getSize();
221 // Test for explicit types first
222 if( iSize > 2 )
223 {
224 if( (s[0] >= '0' && s[0] <= '9') || s[0] == '+' || s[0] == '-' )
225 {
226 }
227 else
228 {
229 QByteArray st = s.toLower();
230 if( st == "true" )
231 {
232 return new Gats::Boolean( true );
233 }
234 else if( st == "false" )
235 {
236 return new Gats::Boolean( false );
237 }
238 }
239 }
240 }
241 break;
242 }
243
244 return NULL;
245}
246
247Gats::Object *Gats::Object::strToGats( const QByteArray &sStr )
248{
249 QByteArray::const_iterator i = sStr.begin();
250
251 return strToGats( i );
252}
253
254Bu::Formatter &operator<<( Bu::Formatter &f, const Gats::Object &obj )
255{
256 switch( obj.getType() )
257 {
258 case Gats::typeDictionary:
259 return f << dynamic_cast<const Gats::Dictionary &>(obj);
260
261 case Gats::typeList:
262 return f << dynamic_cast<const Gats::List &>(obj);
263
264 case Gats::typeString:
265 return f << dynamic_cast<const Gats::String &>(obj);
266
267 case Gats::typeInteger:
268 return f << dynamic_cast<const Gats::Integer &>(obj);
269
270 case Gats::typeFloat:
271 return f << dynamic_cast<const Gats::Float &>(obj);
272
273 case Gats::typeBoolean:
274 return f << dynamic_cast<const Gats::Boolean &>(obj);
275
276 default:
277 return f << "***ERROR: Bad Gats type***";
278 }
279}
280
281Bu::Formatter &operator<<( Bu::Formatter &f, const Gats::Type &t )
282{
283 switch( t )
284 {
285 case Gats::typeDictionary: return f << "dictionary";
286 case Gats::typeList: return f << "list";
287 case Gats::typeString: return f << "string";
288 case Gats::typeInteger: return f << "integer";
289 case Gats::typeFloat: return f << "float";
290 case Gats::typeBoolean: return f << "boolean";
291 }
292
293 return f << "***unknown***";
294}
295*/
296const char *Gats::typeToStr( Gats::Type t )
297{
298 switch( t )
299 {
300 case Gats::typeDictionary: return "dictionary";
301 case Gats::typeList: return "list";
302 case Gats::typeString: return "string";
303 case Gats::typeInteger: return "integer";
304 case Gats::typeFloat: return "float";
305 case Gats::typeBoolean: return "boolean";
306 }
307
308 return "***unknown***";
309}
310
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 @@
1#ifndef GATS_OBJECT_H
2#define GATS_OBJECT_H
3
4#include <QObject>
5#include <QByteArray>
6
7class QIODevice;
8
9namespace Gats
10{
11 enum Type
12 {
13 typeDictionary,
14 typeList,
15 typeString,
16 typeInteger,
17 typeFloat,
18 typeBoolean
19 };
20
21 /**
22 * The baseclass for every type that can be stored in a packet.
23 */
24 class Object : public QObject
25 {
26 Q_OBJECT;
27 public:
28 Object();
29 virtual ~Object();
30
31 virtual Type getType() const =0;
32
33 virtual void write( QIODevice &rOut ) const=0;
34 virtual void read( QIODevice &rIn, char cType )=0;
35
36 static Object *read( QIODevice &rIn );
37// static Object *strToGats( const &sStr );
38
39 private:
40// static Object *strToGats( QByteArray::const_iterator &i );
41// static QByteArray token( QByteArray::const_iterator &i );
42// static void skipWs( QByteArray::const_iterator &i );
43 };
44
45 const char *typeToStr( Type t );
46};
47
48//Bu::Formatter &operator<<( Bu::Formatter &f, const Gats::Object &obj );
49//Bu::Formatter &operator<<( Bu::Formatter &f, const Gats::Type &t );
50
51#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 @@
1#include "gats-qt/string.h"
2
3#include "gats-qt/integer.h"
4
5Gats::String::String()
6{
7}
8
9Gats::String::String( const char *s ) :
10 QByteArray( s )
11{
12}
13
14Gats::String::String( const char *s, long iLength ) :
15 QByteArray( s, iLength )
16{
17}
18
19Gats::String::String( long iLength ) :
20 QByteArray( iLength, '\0' )
21{
22}
23
24Gats::String::String( const String &s ) :
25 QByteArray( s )
26{
27}
28
29Gats::String::String( const QByteArray &s ) :
30 QByteArray( s )
31{
32}
33
34Gats::String::~String()
35{
36}
37
38void Gats::String::write( QIODevice &rOut ) const
39{
40 rOut.write("s", 1 );
41 uint32_t iSize = size();
42 Gats::Integer::writePackedInt( rOut, iSize );
43 rOut.write( constData(), iSize );
44}
45
46void Gats::String::read( QIODevice &rIn, char cType )
47{
48 uint32_t iSize;
49 Gats::Integer::readPackedInt( rIn, iSize );
50 fill( '\0', iSize );
51 rIn.read( data(), iSize );
52}
53/*
54Bu::Formatter &operator<<( Bu::Formatter &f, const Gats::String &s )
55{
56 return f << "(str) \"" << dynamic_cast<const QByteArray &>(s) << "\"";
57}
58*/
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 @@
1#ifndef GATS_STRING_H
2#define GATS_STRING_H
3
4#include "gats-qt/object.h"
5#include <QByteArray>
6
7namespace Gats
8{
9 class String : public Gats::Object, public QByteArray
10 {
11 Q_OBJECT;
12 public:
13 String();
14 String( const char *s );
15 String( const char *s, long iLength );
16 String( long iLength );
17 String( const String &s );
18 String( const QByteArray &s );
19 virtual ~String();
20
21 virtual Type getType() const { return typeString; }
22
23 virtual void write( QIODevice &rOut ) const;
24 virtual void read( QIODevice &rIn, char cType );
25
26 private:
27 };
28};
29
30//Bu::Formatter &operator<<( Bu::Formatter &f, const Gats::String &s );
31
32#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 @@
1#include "gats-qt/object.h"
2#include "gats-qt/boolean.h"
3#include "gats-qt/dictionary.h"
4#include "gats-qt/float.h"
5#include "gats-qt/integer.h"
6#include "gats-qt/list.h"
7#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 @@
1#ifndef LIBGATS_VC_ID
2#define LIBGATS_VC_ID "68:71"
3#endif
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-15 10:18:01 +0000