qdatastream.h
上传用户:detong
上传日期:2022-06-22
资源大小:20675k
文件大小:11k
源码类别:

系统编程

开发平台:

Unix_Linux

  1. /****************************************************************************
  2. **
  3. ** Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies).
  4. ** Contact: Qt Software Information (qt-info@nokia.com)
  5. **
  6. ** This file is part of the QtCore module of the Qt Toolkit.
  7. **
  8. ** Commercial Usage
  9. ** Licensees holding valid Qt Commercial licenses may use this file in
  10. ** accordance with the Qt Commercial License Agreement provided with the
  11. ** Software or, alternatively, in accordance with the terms contained in
  12. ** a written agreement between you and Nokia.
  13. **
  14. **
  15. ** GNU General Public License Usage
  16. ** Alternatively, this file may be used under the terms of the GNU
  17. ** General Public License versions 2.0 or 3.0 as published by the Free
  18. ** Software Foundation and appearing in the file LICENSE.GPL included in
  19. ** the packaging of this file.  Please review the following information
  20. ** to ensure GNU General Public Licensing requirements will be met:
  21. ** http://www.fsf.org/licensing/licenses/info/GPLv2.html and
  22. ** http://www.gnu.org/copyleft/gpl.html.  In addition, as a special
  23. ** exception, Nokia gives you certain additional rights. These rights
  24. ** are described in the Nokia Qt GPL Exception version 1.3, included in
  25. ** the file GPL_EXCEPTION.txt in this package.
  26. **
  27. ** Qt for Windows(R) Licensees
  28. ** As a special exception, Nokia, as the sole copyright holder for Qt
  29. ** Designer, grants users of the Qt/Eclipse Integration plug-in the
  30. ** right for the Qt/Eclipse Integration to link to functionality
  31. ** provided by Qt Designer and its related libraries.
  32. **
  33. ** If you are unsure which license is appropriate for your use, please
  34. ** contact the sales department at qt-sales@nokia.com.
  35. **
  36. ****************************************************************************/
  37. #ifndef QDATASTREAM_H
  38. #define QDATASTREAM_H
  39. #include <QtCore/qiodevice.h>
  40. #include <QtCore/qglobal.h>
  41. #ifdef Status
  42. #error qdatastream.h must be included before any header file that defines Status
  43. #endif
  44. QT_BEGIN_HEADER
  45. QT_BEGIN_NAMESPACE
  46. QT_MODULE(Core)
  47. class QByteArray;
  48. class QIODevice;
  49. template <typename T> class QList;
  50. template <typename T> class QLinkedList;
  51. template <typename T> class QVector;
  52. template <typename T> class QSet;
  53. template <class Key, class T> class QHash;
  54. template <class Key, class T> class QMap;
  55. class QDataStreamPrivate;
  56. #ifndef QT_NO_DATASTREAM
  57. class Q_CORE_EXPORT QDataStream
  58. {
  59. public:
  60.     enum Version {
  61.         Qt_1_0 = 1,
  62.         Qt_2_0 = 2,
  63.         Qt_2_1 = 3,
  64.         Qt_3_0 = 4,
  65.         Qt_3_1 = 5,
  66.         Qt_3_3 = 6,
  67.         Qt_4_0 = 7,
  68.         Qt_4_1 = Qt_4_0,
  69.         Qt_4_2 = 8,
  70.         Qt_4_3 = 9,
  71.         Qt_4_4 = 10
  72. #if QT_VERSION >= 0x040500
  73. #error Add Qt_4_5 = Qt_4_4
  74. #endif
  75.     };
  76.     enum ByteOrder {
  77.         BigEndian = QSysInfo::BigEndian,
  78.         LittleEndian = QSysInfo::LittleEndian
  79.     };
  80.     enum Status {
  81.         Ok,
  82.         ReadPastEnd,
  83. ReadCorruptData
  84.     };
  85.     QDataStream();
  86.     explicit QDataStream(QIODevice *);
  87. #ifdef QT3_SUPPORT
  88.     QDataStream(QByteArray *, int mode);
  89. #endif
  90.     QDataStream(QByteArray *, QIODevice::OpenMode flags);
  91.     QDataStream(const QByteArray &);
  92.     virtual ~QDataStream();
  93.     QIODevice *device() const;
  94.     void setDevice(QIODevice *);
  95.     void unsetDevice();
  96.     bool atEnd() const;
  97. #ifdef QT3_SUPPORT
  98.     inline QT3_SUPPORT bool eof() const { return atEnd(); }
  99. #endif
  100.     Status status() const;
  101.     void setStatus(Status status);
  102.     void resetStatus();
  103.     ByteOrder byteOrder() const;
  104.     void setByteOrder(ByteOrder);
  105.     int version() const;
  106.     void setVersion(int);
  107.     QDataStream &operator>>(qint8 &i);
  108.     QDataStream &operator>>(quint8 &i);
  109.     QDataStream &operator>>(qint16 &i);
  110.     QDataStream &operator>>(quint16 &i);
  111.     QDataStream &operator>>(qint32 &i);
  112.     QDataStream &operator>>(quint32 &i);
  113.     QDataStream &operator>>(qint64 &i);
  114.     QDataStream &operator>>(quint64 &i);
  115.     QDataStream &operator>>(bool &i);
  116.     QDataStream &operator>>(float &f);
  117.     QDataStream &operator>>(double &f);
  118.     QDataStream &operator>>(char *&str);
  119.     QDataStream &operator<<(qint8 i);
  120.     QDataStream &operator<<(quint8 i);
  121.     QDataStream &operator<<(qint16 i);
  122.     QDataStream &operator<<(quint16 i);
  123.     QDataStream &operator<<(qint32 i);
  124.     QDataStream &operator<<(quint32 i);
  125.     QDataStream &operator<<(qint64 i);
  126.     QDataStream &operator<<(quint64 i);
  127.     QDataStream &operator<<(bool i);
  128.     QDataStream &operator<<(float f);
  129.     QDataStream &operator<<(double f);
  130.     QDataStream &operator<<(const char *str);
  131.     QDataStream &readBytes(char *&, uint &len);
  132.     int readRawData(char *, int len);
  133.     QDataStream &writeBytes(const char *, uint len);
  134.     int writeRawData(const char *, int len);
  135.     int skipRawData(int len);
  136. #ifdef QT3_SUPPORT
  137.     inline QT3_SUPPORT QDataStream &readRawBytes(char *str, uint len)
  138.         { readRawData(str, static_cast<int>(len)); return *this; }
  139.     inline QT3_SUPPORT QDataStream &writeRawBytes(const char *str, uint len)
  140.         { writeRawData(str, static_cast<int>(len)); return *this; }
  141.     inline QT3_SUPPORT bool isPrintableData() const { return false; }
  142.     inline QT3_SUPPORT void setPrintableData(bool) {}
  143. #endif
  144. private:
  145.     Q_DISABLE_COPY(QDataStream)
  146.     QDataStreamPrivate *d;
  147.     QIODevice *dev;
  148.     bool owndev;
  149.     bool noswap;
  150.     ByteOrder byteorder;
  151.     int ver;
  152.     Status q_status;
  153. };
  154. /*****************************************************************************
  155.   QDataStream inline functions
  156.  *****************************************************************************/
  157. inline QIODevice *QDataStream::device() const
  158. { return dev; }
  159. inline QDataStream::ByteOrder QDataStream::byteOrder() const
  160. { return byteorder; }
  161. inline int QDataStream::version() const
  162. { return ver; }
  163. inline void QDataStream::setVersion(int v)
  164. { ver = v; }
  165. inline QDataStream &QDataStream::operator>>(quint8 &i)
  166. { return *this >> reinterpret_cast<qint8&>(i); }
  167. inline QDataStream &QDataStream::operator>>(quint16 &i)
  168. { return *this >> reinterpret_cast<qint16&>(i); }
  169. inline QDataStream &QDataStream::operator>>(quint32 &i)
  170. { return *this >> reinterpret_cast<qint32&>(i); }
  171. inline QDataStream &QDataStream::operator>>(quint64 &i)
  172. { return *this >> reinterpret_cast<qint64&>(i); }
  173. inline QDataStream &QDataStream::operator<<(quint8 i)
  174. { return *this << qint8(i); }
  175. inline QDataStream &QDataStream::operator<<(quint16 i)
  176. { return *this << qint16(i); }
  177. inline QDataStream &QDataStream::operator<<(quint32 i)
  178. { return *this << qint32(i); }
  179. inline QDataStream &QDataStream::operator<<(quint64 i)
  180. { return *this << qint64(i); }
  181. template <typename T>
  182. QDataStream& operator>>(QDataStream& s, QList<T>& l)
  183. {
  184.     l.clear();
  185.     quint32 c;
  186.     s >> c;
  187.     for(quint32 i = 0; i < c; ++i)
  188.     {
  189.         T t;
  190.         s >> t;
  191.         l.append(t);
  192.         if (s.atEnd())
  193.             break;
  194.     }
  195.     return s;
  196. }
  197. template <typename T>
  198. QDataStream& operator<<(QDataStream& s, const QList<T>& l)
  199. {
  200.     s << quint32(l.size());
  201.     for (int i = 0; i < l.size(); ++i)
  202.         s << l.at(i);
  203.     return s;
  204. }
  205. template <typename T>
  206. QDataStream& operator>>(QDataStream& s, QLinkedList<T>& l)
  207. {
  208.     l.clear();
  209.     quint32 c;
  210.     s >> c;
  211.     for(quint32 i = 0; i < c; ++i)
  212.     {
  213.         T t;
  214.         s >> t;
  215.         l.append(t);
  216.         if (s.atEnd())
  217.             break;
  218.     }
  219.     return s;
  220. }
  221. template <typename T>
  222. QDataStream& operator<<(QDataStream& s, const QLinkedList<T>& l)
  223. {
  224.     s << quint32(l.size());
  225.     typename QLinkedList<T>::ConstIterator it = l.constBegin();
  226.     for(; it != l.constEnd(); ++it)
  227.         s << *it;
  228.     return s;
  229. }
  230. template<typename T>
  231. QDataStream& operator>>(QDataStream& s, QVector<T>& v)
  232. {
  233.     v.clear();
  234.     quint32 c;
  235.     s >> c;
  236.     v.resize(c);
  237.     for(quint32 i = 0; i < c; ++i) {
  238.         T t;
  239.         s >> t;
  240.         v[i] = t;
  241.     }
  242.     return s;
  243. }
  244. template<typename T>
  245. QDataStream& operator<<(QDataStream& s, const QVector<T>& v)
  246. {
  247.     s << quint32(v.size());
  248.     for (typename QVector<T>::const_iterator it = v.begin(); it != v.end(); ++it)
  249.         s << *it;
  250.     return s;
  251. }
  252. template <typename T>
  253. QDataStream &operator>>(QDataStream &in, QSet<T> &set)
  254. {
  255.     set.clear();
  256.     quint32 c;
  257.     in >> c;
  258.     for (quint32 i = 0; i < c; ++i) {
  259.         T t;
  260.         in >> t;
  261.         set << t;
  262.         if (in.atEnd())
  263.             break;
  264.     }
  265.     return in;
  266. }
  267. template <typename T>
  268. QDataStream& operator<<(QDataStream &out, const QSet<T> &set)
  269. {
  270.     out << quint32(set.size());
  271.     typename QSet<T>::const_iterator i = set.constBegin();
  272.     while (i != set.constEnd()) {
  273.         out << *i;
  274.         ++i;
  275.     }
  276.     return out;
  277. }
  278. template <class Key, class T>
  279. Q_OUTOFLINE_TEMPLATE QDataStream &operator>>(QDataStream &in, QHash<Key, T> &hash)
  280. {
  281.     QDataStream::Status oldStatus = in.status();
  282.     in.resetStatus();
  283.     hash.clear();
  284.     quint32 n;
  285.     in >> n;
  286.     for (quint32 i = 0; i < n; ++i) {
  287.         if (in.status() != QDataStream::Ok)
  288.             break;
  289.         Key k;
  290.         T t;
  291.         in >> k >> t;
  292.         hash.insertMulti(k, t);
  293.     }
  294.     if (in.status() != QDataStream::Ok)
  295.         hash.clear();
  296.     if (oldStatus != QDataStream::Ok)
  297.         in.setStatus(oldStatus);
  298.     return in;
  299. }
  300. template <class Key, class T>
  301. Q_OUTOFLINE_TEMPLATE QDataStream &operator<<(QDataStream &out, const QHash<Key, T>& hash)
  302. {
  303.     out << quint32(hash.size());
  304.     typename QHash<Key, T>::ConstIterator it = hash.end();
  305.     typename QHash<Key, T>::ConstIterator begin = hash.begin();
  306.     while (it != begin) {
  307.         --it;
  308.         out << it.key() << it.value();
  309.     }
  310.     return out;
  311. }
  312. #ifdef qdoc
  313. template <class Key, class T>
  314. Q_OUTOFLINE_TEMPLATE QDataStream &operator>>(QDataStream &in, QMap<Key, T> &map)
  315. #else
  316. template <class aKey, class aT>
  317. Q_OUTOFLINE_TEMPLATE QDataStream &operator>>(QDataStream &in, QMap<aKey, aT> &map)
  318. #endif
  319. {
  320.     QDataStream::Status oldStatus = in.status();
  321.     in.resetStatus();
  322.     map.clear();
  323.     quint32 n;
  324.     in >> n;
  325.     map.detach();
  326.     map.setInsertInOrder(true);
  327.     for (quint32 i = 0; i < n; ++i) {
  328.         if (in.status() != QDataStream::Ok)
  329.             break;
  330.         aKey key;
  331.         aT value;
  332.         in >> key >> value;
  333.         map.insertMulti(key, value);
  334.     }
  335.     map.setInsertInOrder(false);
  336.     if (in.status() != QDataStream::Ok)
  337.         map.clear();
  338.     if (oldStatus != QDataStream::Ok)
  339.         in.setStatus(oldStatus);
  340.     return in;
  341. }
  342. template <class Key, class T>
  343. Q_OUTOFLINE_TEMPLATE QDataStream &operator<<(QDataStream &out, const QMap<Key, T> &map)
  344. {
  345.     out << quint32(map.size());
  346.     typename QMap<Key, T>::ConstIterator it = map.end();
  347.     typename QMap<Key, T>::ConstIterator begin = map.begin();
  348.     while (it != begin) {
  349.         --it;
  350.         out << it.key() << it.value();
  351.     }
  352.     return out;
  353. }
  354. #endif // QT_NO_DATASTREAM
  355. QT_END_NAMESPACE
  356. QT_END_HEADER
  357. #endif // QDATASTREAM_H