← Back to branch summary

~oif-team/ubuntu/natty/qt4-x11/xi2.1

« back to all changes in this revision

Viewing changes to src/corelib/io/qdatastream.h

  • Committer: Bazaar Package Importer
  • Author(s): Adam Conrad
  • Date: 2005-08-24 04:09:09 UTC
  • Revision ID: james.westby@ubuntu.com-20050824040909-xmxe9jfr4a0w5671
Tags: upstream-4.0.0
Import upstream version 4.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/corelib/io/qdatastream.h
 
1
/****************************************************************************
 
2
**
 
3
** Copyright (C) 1992-2005 Trolltech AS. All rights reserved.
 
4
**
 
5
** This file is part of the core module of the Qt Toolkit.
 
6
**
 
7
** This file may be distributed under the terms of the Q Public License
 
8
** as defined by Trolltech AS of Norway and appearing in the file
 
9
** LICENSE.QPL included in the packaging of this file.
 
10
**
 
11
** This file may be distributed and/or modified under the terms of the
 
12
** GNU General Public License version 2 as published by the Free Software
 
13
** Foundation and appearing in the file LICENSE.GPL included in the
 
14
** packaging of this file.
 
15
**
 
16
** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 
17
**   information about Qt Commercial License Agreements.
 
18
** See http://www.trolltech.com/qpl/ for QPL licensing information.
 
19
** See http://www.trolltech.com/gpl/ for GPL licensing information.
 
20
**
 
21
** Contact info@trolltech.com if any conditions of this licensing are
 
22
** not clear to you.
 
23
**
 
24
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 
25
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 
26
**
 
27
****************************************************************************/
 
28
 
 
29
#ifndef QDATASTREAM_H
 
30
#define QDATASTREAM_H
 
31
 
 
32
#include "QtCore/qiodevice.h"
 
33
#include "QtCore/qglobal.h"
 
34
 
 
35
class QByteArray;
 
36
class QIODevice;
 
37
 
 
38
template <typename T> class QList;
 
39
template <typename T> class QLinkedList;
 
40
template <typename T> class QVector;
 
41
template <typename T> class QSet;
 
42
template <class Key, class T> class QHash;
 
43
template <class Key, class T> class QMap;
 
44
 
 
45
class QDataStreamPrivate;
 
46
 
 
47
#ifndef QT_NO_DATASTREAM
 
48
class Q_CORE_EXPORT QDataStream
 
49
{
 
50
public:
 
51
    enum Version {
 
52
        Qt_1_0 = 1,
 
53
        Qt_2_0 = 2,
 
54
        Qt_2_1 = 3,
 
55
        Qt_3_0 = 4,
 
56
        Qt_3_1 = 5,
 
57
        Qt_3_3 = 6,
 
58
        Qt_4_0 = 7
 
59
#if QT_VERSION >= 0x040100
 
60
#error "Add Qt_4_1 = Qt_4_0"
 
61
#endif
 
62
    };
 
63
 
 
64
    enum ByteOrder {
 
65
        BigEndian = QSysInfo::BigEndian,
 
66
        LittleEndian = QSysInfo::LittleEndian
 
67
    };
 
68
 
 
69
#ifdef Status
 
70
#error This file has to be included after any system files that define Status
 
71
#endif
 
72
    enum Status {
 
73
        Ok,
 
74
        ReadPastEnd,
 
75
        ReadCorruptData
 
76
    };
 
77
 
 
78
    QDataStream();
 
79
    explicit QDataStream(QIODevice *);
 
80
#ifdef QT3_SUPPORT
 
81
    QDataStream(QByteArray *, int mode);
 
82
#endif
 
83
    QDataStream(QByteArray *, QIODevice::OpenMode flags);
 
84
    QDataStream(const QByteArray &);
 
85
    virtual ~QDataStream();
 
86
 
 
87
    QIODevice *device() const;
 
88
    void setDevice(QIODevice *);
 
89
    void unsetDevice();
 
90
 
 
91
    bool atEnd() const;
 
92
#ifdef QT3_SUPPORT
 
93
    inline QT3_SUPPORT bool eof() const { return atEnd(); }
 
94
#endif
 
95
 
 
96
    Status status() const;
 
97
    void setStatus(Status status);
 
98
    void resetStatus();
 
99
 
 
100
    ByteOrder byteOrder() const;
 
101
    void setByteOrder(ByteOrder);
 
102
 
 
103
    int version() const;
 
104
    void setVersion(int);
 
105
 
 
106
    QDataStream &operator>>(qint8 &i);
 
107
    QDataStream &operator>>(quint8 &i);
 
108
    QDataStream &operator>>(qint16 &i);
 
109
    QDataStream &operator>>(quint16 &i);
 
110
    QDataStream &operator>>(qint32 &i);
 
111
    QDataStream &operator>>(quint32 &i);
 
112
    QDataStream &operator>>(qint64 &i);
 
113
    QDataStream &operator>>(quint64 &i);
 
114
 
 
115
    QDataStream &operator>>(bool &i);
 
116
    QDataStream &operator>>(float &f);
 
117
    QDataStream &operator>>(double &f);
 
118
    QDataStream &operator>>(char *&str);
 
119
 
 
120
    QDataStream &operator<<(qint8 i);
 
121
    QDataStream &operator<<(quint8 i);
 
122
    QDataStream &operator<<(qint16 i);
 
123
    QDataStream &operator<<(quint16 i);
 
124
    QDataStream &operator<<(qint32 i);
 
125
    QDataStream &operator<<(quint32 i);
 
126
    QDataStream &operator<<(qint64 i);
 
127
    QDataStream &operator<<(quint64 i);
 
128
    QDataStream &operator<<(bool i);
 
129
    QDataStream &operator<<(float f);
 
130
    QDataStream &operator<<(double f);
 
131
    QDataStream &operator<<(const char *str);
 
132
 
 
133
    QDataStream &readBytes(char *&, uint &len);
 
134
    int readRawData(char *, int len);
 
135
 
 
136
    QDataStream &writeBytes(const char *, uint len);
 
137
    int writeRawData(const char *, int len);
 
138
 
 
139
#ifdef QT3_SUPPORT
 
140
    inline QT3_SUPPORT QDataStream &readRawBytes(char *str, uint len)
 
141
        { readRawData(str, (int)len); return *this; }
 
142
    inline QT3_SUPPORT QDataStream &writeRawBytes(const char *str, uint len)
 
143
        { writeRawData(str, (int)len); return *this; }
 
144
    inline QT3_SUPPORT bool isPrintableData() const { return false; }
 
145
    inline QT3_SUPPORT void setPrintableData(bool) {}
 
146
#endif
 
147
 
 
148
private:
 
149
    Q_DISABLE_COPY(QDataStream)
 
150
 
 
151
    QDataStreamPrivate *d;
 
152
 
 
153
    QIODevice *dev;
 
154
    bool owndev;
 
155
    bool noswap;
 
156
    ByteOrder byteorder;
 
157
    int ver;
 
158
    Status q_status;
 
159
};
 
160
 
 
161
 
 
162
/*****************************************************************************
 
163
  QDataStream inline functions
 
164
 *****************************************************************************/
 
165
 
 
166
inline QIODevice *QDataStream::device() const
 
167
{ return dev; }
 
168
 
 
169
inline QDataStream::ByteOrder QDataStream::byteOrder() const
 
170
{ return byteorder; }
 
171
 
 
172
inline int QDataStream::version() const
 
173
{ return ver; }
 
174
 
 
175
inline void QDataStream::setVersion(int v)
 
176
{ ver = v; }
 
177
 
 
178
inline QDataStream &QDataStream::operator>>(quint8 &i)
 
179
{ return *this >> reinterpret_cast<qint8&>(i); }
 
180
 
 
181
inline QDataStream &QDataStream::operator>>(quint16 &i)
 
182
{ return *this >> reinterpret_cast<qint16&>(i); }
 
183
 
 
184
inline QDataStream &QDataStream::operator>>(quint32 &i)
 
185
{ return *this >> reinterpret_cast<qint32&>(i); }
 
186
 
 
187
inline QDataStream &QDataStream::operator>>(quint64 &i)
 
188
{ return *this >> reinterpret_cast<qint64&>(i); }
 
189
 
 
190
inline QDataStream &QDataStream::operator<<(quint8 i)
 
191
{ return *this << qint8(i); }
 
192
 
 
193
inline QDataStream &QDataStream::operator<<(quint16 i)
 
194
{ return *this << qint16(i); }
 
195
 
 
196
inline QDataStream &QDataStream::operator<<(quint32 i)
 
197
{ return *this << qint32(i); }
 
198
 
 
199
inline QDataStream &QDataStream::operator<<(quint64 i)
 
200
{ return *this << qint64(i); }
 
201
 
 
202
template <typename T>
 
203
QDataStream& operator>>(QDataStream& s, QList<T>& l)
 
204
{
 
205
    l.clear();
 
206
    quint32 c;
 
207
    s >> c;
 
208
    for(quint32 i = 0; i < c; ++i)
 
209
    {
 
210
        T t;
 
211
        s >> t;
 
212
        l.append(t);
 
213
        if (s.atEnd())
 
214
            break;
 
215
    }
 
216
    return s;
 
217
}
 
218
 
 
219
template <typename T>
 
220
QDataStream& operator<<(QDataStream& s, const QList<T>& l)
 
221
{
 
222
    s << quint32(l.size());
 
223
    for (int i = 0; i < l.size(); ++i)
 
224
        s << l.at(i);
 
225
    return s;
 
226
}
 
227
 
 
228
template <typename T>
 
229
QDataStream& operator>>(QDataStream& s, QLinkedList<T>& l)
 
230
{
 
231
    l.clear();
 
232
    quint32 c;
 
233
    s >> c;
 
234
    for(quint32 i = 0; i < c; ++i)
 
235
    {
 
236
        T t;
 
237
        s >> t;
 
238
        l.append(t);
 
239
        if (s.atEnd())
 
240
            break;
 
241
    }
 
242
    return s;
 
243
}
 
244
 
 
245
template <typename T>
 
246
QDataStream& operator<<(QDataStream& s, const QLinkedList<T>& l)
 
247
{
 
248
    s << quint32(l.size());
 
249
    typename QLinkedList<T>::ConstIterator it = l.constBegin();
 
250
    for(; it != l.constEnd(); ++it)
 
251
        s << *it;
 
252
    return s;
 
253
}
 
254
 
 
255
template<typename T>
 
256
QDataStream& operator>>(QDataStream& s, QVector<T>& v)
 
257
{
 
258
    v.clear();
 
259
    quint32 c;
 
260
    s >> c;
 
261
    v.resize(c);
 
262
    for(quint32 i = 0; i < c; ++i) {
 
263
        T t;
 
264
        s >> t;
 
265
        v[i] = t;
 
266
    }
 
267
    return s;
 
268
}
 
269
 
 
270
template<typename T>
 
271
QDataStream& operator<<(QDataStream& s, const QVector<T>& v)
 
272
{
 
273
    s << quint32(v.size());
 
274
    const T* it = v.begin();
 
275
    for(; it != v.end(); ++it)
 
276
        s << *it;
 
277
    return s;
 
278
}
 
279
 
 
280
template <typename T>
 
281
QDataStream &operator>>(QDataStream &in, QSet<T> &set)
 
282
{
 
283
    set.clear();
 
284
    quint32 c;
 
285
    in >> c;
 
286
    for (quint32 i = 0; i < c; ++i) {
 
287
        T t;
 
288
        in >> t;
 
289
        set << t;
 
290
        if (in.atEnd())
 
291
            break;
 
292
    }
 
293
    return in;
 
294
}
 
295
 
 
296
template <typename T>
 
297
QDataStream& operator<<(QDataStream &out, const QSet<T> &set)
 
298
{
 
299
    out << quint32(set.size());
 
300
    typename QSet<T>::const_iterator i = set.constBegin();
 
301
    while (i != set.constEnd()) {
 
302
        out << *i;
 
303
        ++i;
 
304
    }
 
305
    return out;
 
306
}
 
307
 
 
308
template <class Key, class T>
 
309
Q_OUTOFLINE_TEMPLATE QDataStream &operator>>(QDataStream &in, QHash<Key, T> &hash)
 
310
{
 
311
    QDataStream::Status oldStatus = in.status();
 
312
    in.resetStatus();
 
313
    hash.clear();
 
314
 
 
315
    quint32 n;
 
316
    in >> n;
 
317
 
 
318
    for (quint32 i = 0; i < n; ++i) {
 
319
        if (in.status() != QDataStream::Ok)
 
320
            break;
 
321
 
 
322
        Key k;
 
323
        T t;
 
324
        in >> k >> t;
 
325
        hash.insert(k, t);
 
326
    }
 
327
 
 
328
    if (in.status() != QDataStream::Ok)
 
329
        hash.clear();
 
330
    if (oldStatus != QDataStream::Ok)
 
331
        in.setStatus(oldStatus);
 
332
    return in;
 
333
}
 
334
 
 
335
template <class Key, class T>
 
336
Q_OUTOFLINE_TEMPLATE QDataStream &operator<<(QDataStream &out, const QHash<Key, T>& hash)
 
337
{
 
338
    out << quint32(hash.size());
 
339
    typename QHash<Key, T>::ConstIterator it = hash.begin();
 
340
    while (it != hash.end()) {
 
341
        out << it.key() << it.value();
 
342
        ++it;
 
343
    }
 
344
    return out;
 
345
}
 
346
#ifdef qdoc
 
347
template <class Key, class T>
 
348
Q_OUTOFLINE_TEMPLATE QDataStream &operator>>(QDataStream &in, QMap<Key, T> &map)
 
349
#else
 
350
template <class aKey, class aT>
 
351
Q_OUTOFLINE_TEMPLATE QDataStream &operator>>(QDataStream &in, QMap<aKey, aT> &map)
 
352
#endif
 
353
{
 
354
    QDataStream::Status oldStatus = in.status();
 
355
    in.resetStatus();
 
356
    map.clear();
 
357
 
 
358
    quint32 n;
 
359
    in >> n;
 
360
 
 
361
    map.detach();
 
362
#if !defined(Q_CC_BOR)
 
363
    map.d->insertInOrder = true;
 
364
#endif
 
365
    for (quint32 i = 0; i < n; ++i) {
 
366
        if (in.status() != QDataStream::Ok)
 
367
            break;
 
368
 
 
369
        aKey key;
 
370
        aT value;
 
371
        in >> key >> value;
 
372
        map.insert(key, value);
 
373
    }
 
374
#if !defined(Q_CC_BOR)
 
375
    map.d->insertInOrder = false;
 
376
#endif
 
377
    if (in.status() != QDataStream::Ok)
 
378
        map.clear();
 
379
    if (oldStatus != QDataStream::Ok)
 
380
        in.setStatus(oldStatus);
 
381
    return in;
 
382
}
 
383
 
 
384
template <class Key, class T>
 
385
Q_OUTOFLINE_TEMPLATE QDataStream &operator<<(QDataStream &out, const QMap<Key, T> &map)
 
386
{
 
387
    out << quint32(map.size());
 
388
    typename QMap<Key, T>::ConstIterator it = map.begin();
 
389
    while (it != map.end()) {
 
390
        out << it.key() << it.value();
 
391
        ++it;
 
392
    }
 
393
    return out;
 
394
}
 
395
 
 
396
#endif // QT_NO_DATASTREAM
 
397
 
 
398
#endif // QDATASTREAM_H