1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtCore module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #ifndef QTEXTSTREAM_H

    43 #define QTEXTSTREAM_H

    44 

    45 #include <QtCore/qiodevice.h>

    46 #include <QtCore/qstring.h>

    47 #include <QtCore/qchar.h>

    48 #include <QtCore/qlocale.h>

    49 #include <QtCore/qscopedpointer.h>

    50 

    51 #ifndef QT_NO_TEXTCODEC

    52 #  ifdef QT3_SUPPORT

    53 #    include <QtCore/qtextcodec.h>

    54 #  endif

    55 #endif

    56 

    57 #include <stdio.h>

    58 

    59 #ifdef Status

    60 #error qtextstream.h must be included before any header file that defines Status

    61 #endif

    62 

    63 QT_BEGIN_HEADER

    64 

    65 QT_BEGIN_NAMESPACE

    66 

    67 QT_MODULE(Core)

    68 

    69 class QTextCodec;

    70 class QTextDecoder;

    71 

    72 class QTextStreamPrivate;

    73 class Q_CORE_EXPORT QTextStream                                // text stream class

    74 {

    75     Q_DECLARE_PRIVATE(QTextStream)

    76 

    77 public:

    78     enum RealNumberNotation {

    79         SmartNotation,

    80         FixedNotation,

    81         ScientificNotation

    82     };

    83     enum FieldAlignment {

    84         AlignLeft,

    85         AlignRight,

    86         AlignCenter,

    87         AlignAccountingStyle

    88     };

    89     enum Status {

    90         Ok,

    91         ReadPastEnd,

    92         ReadCorruptData

    93     };

    94     enum NumberFlag {

    95         ShowBase = 0x1,

    96         ForcePoint = 0x2,

    97         ForceSign = 0x4,

    98         UppercaseBase = 0x8,

    99         UppercaseDigits = 0x10

   100     };

   101     Q_DECLARE_FLAGS(NumberFlags, NumberFlag)

   102 

   103     QTextStream();

   104     explicit QTextStream(QIODevice *device);

   105     explicit QTextStream(FILE *fileHandle, QIODevice::OpenMode openMode = QIODevice::ReadWrite);

   106     explicit QTextStream(QString *string, QIODevice::OpenMode openMode = QIODevice::ReadWrite);

   107     explicit QTextStream(QByteArray *array, QIODevice::OpenMode openMode = QIODevice::ReadWrite);

   108     explicit QTextStream(const QByteArray &array, QIODevice::OpenMode openMode = QIODevice::ReadOnly);

   109     virtual ~QTextStream();

   110 

   111 #ifndef QT_NO_TEXTCODEC

   112     void setCodec(QTextCodec *codec);

   113     void setCodec(const char *codecName);

   114     QTextCodec *codec() const;

   115     void setAutoDetectUnicode(bool enabled);

   116     bool autoDetectUnicode() const;

   117     void setGenerateByteOrderMark(bool generate);

   118     bool generateByteOrderMark() const;

   119 #endif

   120 

   121     void setLocale(const QLocale &locale);

   122     QLocale locale() const;

   123 

   124     void setDevice(QIODevice *device);

   125     QIODevice *device() const;

   126 

   127     void setString(QString *string, QIODevice::OpenMode openMode = QIODevice::ReadWrite);

   128     QString *string() const;

   129 

   130     Status status() const;

   131     void setStatus(Status status);

   132     void resetStatus();

   133 

   134     bool atEnd() const;

   135     void reset();

   136     void flush();

   137     bool seek(qint64 pos);

   138     qint64 pos() const;

   139 

   140     void skipWhiteSpace();

   141 

   142     QString readLine(qint64 maxlen = 0);

   143     QString readAll();

   144     QString read(qint64 maxlen);

   145 

   146     void setFieldAlignment(FieldAlignment alignment);

   147     FieldAlignment fieldAlignment() const;

   148 

   149     void setPadChar(QChar ch);

   150     QChar padChar() const;

   151 

   152     void setFieldWidth(int width);

   153     int fieldWidth() const;

   154 

   155     void setNumberFlags(NumberFlags flags);

   156     NumberFlags numberFlags() const;

   157 

   158     void setIntegerBase(int base);

   159     int integerBase() const;

   160 

   161     void setRealNumberNotation(RealNumberNotation notation);

   162     RealNumberNotation realNumberNotation() const;

   163 

   164     void setRealNumberPrecision(int precision);

   165     int realNumberPrecision() const;

   166 

   167     QTextStream &operator>>(QChar &ch);

   168     QTextStream &operator>>(char &ch);

   169     QTextStream &operator>>(signed short &i);

   170     QTextStream &operator>>(unsigned short &i);

   171     QTextStream &operator>>(signed int &i);

   172     QTextStream &operator>>(unsigned int &i);

   173     QTextStream &operator>>(signed long &i);

   174     QTextStream &operator>>(unsigned long &i);

   175     QTextStream &operator>>(qlonglong &i);

   176     QTextStream &operator>>(qulonglong &i);

   177     QTextStream &operator>>(float &f);

   178     QTextStream &operator>>(double &f);

   179     QTextStream &operator>>(QString &s);

   180     QTextStream &operator>>(QByteArray &array);

   181     QTextStream &operator>>(char *c);

   182 

   183     QTextStream &operator<<(QBool b);

   184     QTextStream &operator<<(QChar ch);

   185     QTextStream &operator<<(char ch);

   186     QTextStream &operator<<(signed short i);

   187     QTextStream &operator<<(unsigned short i);

   188     QTextStream &operator<<(signed int i);

   189     QTextStream &operator<<(unsigned int i);

   190     QTextStream &operator<<(signed long i);

   191     QTextStream &operator<<(unsigned long i);

   192     QTextStream &operator<<(qlonglong i);

   193     QTextStream &operator<<(qulonglong i);

   194     QTextStream &operator<<(float f);

   195     QTextStream &operator<<(double f);

   196     QTextStream &operator<<(const QString &s);

   197     QTextStream &operator<<(const QByteArray &array);

   198     QTextStream &operator<<(const char *c);

   199     QTextStream &operator<<(const void *ptr);

   200 

   201 #ifdef QT3_SUPPORT

   202     // not marked as QT3_SUPPORT to avoid double compiler warnings, as

   203     // they are used in the QT3_SUPPORT functions below.

   204     inline QT3_SUPPORT int flags() const { return flagsInternal(); }

   205     inline QT3_SUPPORT int flags(int f) { return flagsInternal(f); }

   206 

   207     inline QT3_SUPPORT int setf(int bits)

   208     { int old = flagsInternal(); flagsInternal(flagsInternal() | bits); return old; }

   209     inline QT3_SUPPORT int setf(int bits, int mask)

   210     { int old = flagsInternal(); flagsInternal(flagsInternal() | (bits & mask)); return old; }

   211     inline QT3_SUPPORT int unsetf(int bits)

   212     { int old = flagsInternal(); flagsInternal(flagsInternal() & ~bits); return old; }

   213 

   214     inline QT3_SUPPORT int width(int w)

   215     { int old = fieldWidth(); setFieldWidth(w); return old; }

   216     inline QT3_SUPPORT int fill(int f)

   217     { QChar ch = padChar(); setPadChar(QChar(f)); return ch.unicode(); }

   218     inline QT3_SUPPORT int precision(int p)

   219     { int old = realNumberPrecision(); setRealNumberPrecision(p); return old; }

   220 

   221     enum {

   222         skipws       = 0x0001,                        // skip whitespace on input

   223         left         = 0x0002,                        // left-adjust output

   224         right        = 0x0004,                        // right-adjust output

   225         internal     = 0x0008,                        // pad after sign

   226         bin          = 0x0010,                        // binary format integer

   227         oct          = 0x0020,                        // octal format integer

   228         dec          = 0x0040,                        // decimal format integer

   229         hex          = 0x0080,                        // hex format integer

   230         showbase     = 0x0100,                        // show base indicator

   231         showpoint    = 0x0200,                        // force decimal point (float)

   232         uppercase    = 0x0400,                        // upper-case hex output

   233         showpos      = 0x0800,                        // add '+' to positive integers

   234         scientific   = 0x1000,                        // scientific float output

   235         fixed        = 0x2000                         // fixed float output

   236     };

   237     enum {

   238         basefield = bin | oct | dec | hex,

   239         adjustfield = left | right | internal,

   240         floatfield = scientific | fixed

   241     };

   242 

   243 #ifndef QT_NO_TEXTCODEC

   244     enum Encoding { Locale, Latin1, Unicode, UnicodeNetworkOrder,

   245                     UnicodeReverse, RawUnicode, UnicodeUTF8 };

   246     QT3_SUPPORT void setEncoding(Encoding encoding);

   247 #endif

   248     inline QT3_SUPPORT QString read() { return readAll(); }

   249     inline QT3_SUPPORT void unsetDevice() { setDevice(0); }

   250 #endif

   251 

   252 private:

   253 #ifdef QT3_SUPPORT

   254     int flagsInternal() const;

   255     int flagsInternal(int flags);

   256 #endif

   257 

   258     Q_DISABLE_COPY(QTextStream)

   259 

   260     QScopedPointer<QTextStreamPrivate> d_ptr;

   261 };

   262 

   263 Q_DECLARE_OPERATORS_FOR_FLAGS(QTextStream::NumberFlags)

   264 

   265 /*****************************************************************************

   266   QTextStream manipulators

   267  *****************************************************************************/

   268 

   269 typedef QTextStream & (*QTextStreamFunction)(QTextStream &);// manipulator function

   270 typedef void (QTextStream::*QTSMFI)(int); // manipulator w/int argument

   271 typedef void (QTextStream::*QTSMFC)(QChar); // manipulator w/QChar argument

   272 

   273 class Q_CORE_EXPORT QTextStreamManipulator

   274 {

   275 public:

   276     QTextStreamManipulator(QTSMFI m, int a) { mf = m; mc = 0; arg = a; }

   277     QTextStreamManipulator(QTSMFC m, QChar c) { mf = 0; mc = m; ch = c; arg = -1; }

   278     void exec(QTextStream &s) { if (mf) { (s.*mf)(arg); } else { (s.*mc)(ch); } }

   279 

   280 private:

   281     QTSMFI mf;                                        // QTextStream member function

   282     QTSMFC mc;                                        // QTextStream member function

   283     int arg;                                          // member function argument

   284     QChar ch;

   285 };

   286 

   287 inline QTextStream &operator>>(QTextStream &s, QTextStreamFunction f)

   288 { return (*f)(s); }

   289 

   290 inline QTextStream &operator<<(QTextStream &s, QTextStreamFunction f)

   291 { return (*f)(s); }

   292 

   293 inline QTextStream &operator<<(QTextStream &s, QTextStreamManipulator m)

   294 { m.exec(s); return s; }

   295 

   296 Q_CORE_EXPORT QTextStream &bin(QTextStream &s);

   297 Q_CORE_EXPORT QTextStream &oct(QTextStream &s);

   298 Q_CORE_EXPORT QTextStream &dec(QTextStream &s);

   299 Q_CORE_EXPORT QTextStream &hex(QTextStream &s);

   300 

   301 Q_CORE_EXPORT QTextStream &showbase(QTextStream &s);

   302 Q_CORE_EXPORT QTextStream &forcesign(QTextStream &s);

   303 Q_CORE_EXPORT QTextStream &forcepoint(QTextStream &s);

   304 Q_CORE_EXPORT QTextStream &noshowbase(QTextStream &s);

   305 Q_CORE_EXPORT QTextStream &noforcesign(QTextStream &s);

   306 Q_CORE_EXPORT QTextStream &noforcepoint(QTextStream &s);

   307 

   308 Q_CORE_EXPORT QTextStream &uppercasebase(QTextStream &s);

   309 Q_CORE_EXPORT QTextStream &uppercasedigits(QTextStream &s);

   310 Q_CORE_EXPORT QTextStream &lowercasebase(QTextStream &s);

   311 Q_CORE_EXPORT QTextStream &lowercasedigits(QTextStream &s);

   312 

   313 Q_CORE_EXPORT QTextStream &fixed(QTextStream &s);

   314 Q_CORE_EXPORT QTextStream &scientific(QTextStream &s);

   315 

   316 Q_CORE_EXPORT QTextStream &left(QTextStream &s);

   317 Q_CORE_EXPORT QTextStream &right(QTextStream &s);

   318 Q_CORE_EXPORT QTextStream &center(QTextStream &s);

   319 

   320 Q_CORE_EXPORT QTextStream &endl(QTextStream &s);

   321 Q_CORE_EXPORT QTextStream &flush(QTextStream &s);

   322 Q_CORE_EXPORT QTextStream &reset(QTextStream &s);

   323 

   324 Q_CORE_EXPORT QTextStream &bom(QTextStream &s);

   325 

   326 Q_CORE_EXPORT QTextStream &ws(QTextStream &s);

   327 

   328 inline QTextStreamManipulator qSetFieldWidth(int width)

   329 {

   330     QTSMFI func = &QTextStream::setFieldWidth;

   331     return QTextStreamManipulator(func,width);

   332 }

   333 

   334 inline QTextStreamManipulator qSetPadChar(QChar ch)

   335 {

   336     QTSMFC func = &QTextStream::setPadChar;

   337     return QTextStreamManipulator(func, ch);

   338 }

   339 

   340 inline QTextStreamManipulator qSetRealNumberPrecision(int precision)

   341 {

   342     QTSMFI func = &QTextStream::setRealNumberPrecision;

   343     return QTextStreamManipulator(func, precision);

   344 }

   345 

   346 #ifdef QT3_SUPPORT

   347 typedef QTextStream QTS;

   348 

   349 class Q_CORE_EXPORT QTextIStream : public QTextStream

   350 {

   351 public:

   352     inline explicit QTextIStream(const QString *s) : QTextStream(const_cast<QString *>(s), QIODevice::ReadOnly) {}

   353     inline explicit QTextIStream(QByteArray *a) : QTextStream(a, QIODevice::ReadOnly) {}

   354     inline QTextIStream(FILE *f) : QTextStream(f, QIODevice::ReadOnly) {}

   355 

   356 private:

   357     Q_DISABLE_COPY(QTextIStream)

   358 };

   359 

   360 class Q_CORE_EXPORT QTextOStream : public QTextStream

   361 {

   362 public:

   363     inline explicit QTextOStream(QString *s) : QTextStream(s, QIODevice::WriteOnly) {}

   364     inline explicit QTextOStream(QByteArray *a) : QTextStream(a, QIODevice::WriteOnly) {}

   365     inline QTextOStream(FILE *f) : QTextStream(f, QIODevice::WriteOnly) {}

   366 

   367 private:

   368     Q_DISABLE_COPY(QTextOStream)

   369 };

   370 #endif

   371 

   372 QT_END_NAMESPACE

   373 

   374 QT_END_HEADER

   375 

   376 #endif // QTEXTSTREAM_H