QTextStreamPrivate Class Reference

Public Types
enum	NumberParsingStatus { npsOk, npsMissingDigit, npsInvalidPrefix }
enum	TokenDelimiter { Space, NotSpace, EndOfLine }

Public Functions
void	consume (int nchars)
void	consumeLastToken ()
bool	fillReadBuffer (qint64 maxBytes=-1)
void	flushWriteBuffer ()
bool	getChar (QChar *ch)
NumberParsingStatus	getNumber (qulonglong *l)
bool	getReal (double *f)
void	putNumber (qulonglong number, bool negative)
void	putString (const QString &ch, bool number=false)
	QTextStreamPrivate (QTextStream *q_ptr)
QString	read (int maxlen)
const QChar *	readPtr () const
void	reset ()
void	resetReadBuffer ()
void	restoreToSavedConverterState ()
void	saveConverterState (qint64 newPos)
bool	scan (const QChar **ptr, int *tokenLength, int maxlen, TokenDelimiter delimiter)
	Scans no more than maxlen QChars in the current buffer for the first delimiter. More...
void	ungetChar (const QChar &ch)
void	write (const QString &data)
	~QTextStreamPrivate ()

Public Variables
bool	autoDetectUnicode
QTextCodec *	codec
bool	deleteDevice
QIODevice *	device
QDeviceClosedNotifier	deviceClosedNotifier
QTextStream::FieldAlignment	fieldAlignment
int	fieldWidth
int	integerBase
int	lastTokenSize
QLocale	locale
QTextStream::NumberFlags	numberFlags
QChar	padChar
QTextStream *	q_ptr
QString	readBuffer
int	readBufferOffset
qint64	readBufferStartDevicePos
QTextCodec::ConverterState *	readConverterSavedState
int	readConverterSavedStateOffset
QTextCodec::ConverterState	readConverterState
QTextStream::RealNumberNotation	realNumberNotation
int	realNumberPrecision
QTextStream::Status	status
QString *	string
int	stringOffset
QIODevice::OpenMode	stringOpenMode
QString	writeBuffer
QTextCodec::ConverterState	writeConverterState

Detailed Description

Definition at line 357 of file qtextstream.cpp.

Enumerations

NumberParsingStatus

enum QTextStreamPrivate::NumberParsingStatus

Enumerator
npsOk
npsMissingDigit
npsInvalidPrefix

Definition at line 404 of file qtextstream.cpp.

                             {
        npsOk,
        npsMissingDigit,
        npsInvalidPrefix
    };

TokenDelimiter

enum QTextStreamPrivate::TokenDelimiter

Enumerator
Space
NotSpace
EndOfLine

Definition at line 387 of file qtextstream.cpp.

                        {
        Space,
        NotSpace,
        EndOfLine
    };

Constructors and Destructors

QTextStreamPrivate()

QTextStreamPrivate::QTextStreamPrivate

(

QTextStream *

q_ptr

)

Warning

This function is not part of the public interface.

Definition at line 448 of file qtextstream.cpp.

    :
#ifndef QT_NO_TEXTCODEC
    readConverterSavedState(0),
#endif
    readConverterSavedStateOffset(0),
    locale(QLocale::c())
{
    this->q_ptr = q_ptr;
    reset();
}

~QTextStreamPrivate()

QTextStreamPrivate::~QTextStreamPrivate

(

)

Warning

This function is not part of the public interface.

Definition at line 462 of file qtextstream.cpp.

{
    if (deleteDevice) {
#ifndef QT_NO_QOBJECT
        device->blockSignals(true);
#endif
        delete device;
    }
#ifndef QT_NO_TEXTCODEC
    delete readConverterSavedState;
#endif
}

Functions

consume()

void QTextStreamPrivate::consume ( int  size )

inline

Warning

This function is not part of the public interface.

Definition at line 872 of file qtextstream.cpp.

Referenced by consumeLastToken(), and getChar().

{
#if defined (QTEXTSTREAM_DEBUG)
    qDebug("QTextStreamPrivate::consume(%d)", size);
#endif
    if (string) {
        stringOffset += size;
        if (stringOffset > string->size())
            stringOffset = string->size();
    } else {
        readBufferOffset += size;
        if (readBufferOffset >= readBuffer.size()) {
            readBufferOffset = 0;
            readBuffer.clear();
            saveConverterState(device->pos());
        } else if (readBufferOffset > QTEXTSTREAM_BUFFERSIZE) {
            readBuffer = readBuffer.remove(0,readBufferOffset);
            readConverterSavedStateOffset += readBufferOffset;
            readBufferOffset = 0;
        }
    }
}

consumeLastToken()

void QTextStreamPrivate::consumeLastToken ( )

inline

Warning

This function is not part of the public interface.

Definition at line 863 of file qtextstream.cpp.

Referenced by read().

{
    if (lastTokenSize)
        consume(lastTokenSize);
    lastTokenSize = 0;
}

fillReadBuffer()

bool QTextStreamPrivate::fillReadBuffer

(

qint64

maxBytes = -1

)

Warning

This function is not part of the public interface.

Definition at line 531 of file qtextstream.cpp.

Referenced by getChar(), QTextStream::pos(), read(), and scan().

{
    // no buffer next to the QString itself; this function should only
    // be called internally, for devices.
    Q_ASSERT(!string);
    Q_ASSERT(device);

    // handle text translation and bypass the Text flag in the device.
    bool textModeEnabled = device->isTextModeEnabled();
    if (textModeEnabled)
        device->setTextModeEnabled(false);

    // read raw data into a temporary buffer
    char buf[QTEXTSTREAM_BUFFERSIZE];
    qint64 bytesRead = 0;
#if defined(Q_OS_WIN)
    // On Windows, there is no non-blocking stdin - so we fall back to reading
    // lines instead. If there is no QOBJECT, we read lines for all sequential
    // devices; otherwise, we read lines only for stdin.
    QFile *file = 0;
    Q_UNUSED(file);
    if (device->isSequential()
#if !defined(QT_NO_QOBJECT)
        && (file = qobject_cast<QFile *>(device)) && file->handle() == 0
#endif
        ) {
        if (maxBytes != -1)
            bytesRead = device->readLine(buf, qMin<qint64>(sizeof(buf), maxBytes));
        else
            bytesRead = device->readLine(buf, sizeof(buf));
    } else
#endif
    {
        if (maxBytes != -1)
            bytesRead = device->read(buf, qMin<qint64>(sizeof(buf), maxBytes));
        else
            bytesRead = device->read(buf, sizeof(buf));
    }

#ifndef QT_NO_TEXTCODEC
    // codec auto detection, explicitly defaults to locale encoding if the
    // codec has been set to 0.
    if (!codec || autoDetectUnicode) {
        autoDetectUnicode = false;

        codec = QTextCodec::codecForUtfText(QByteArray::fromRawData(buf, bytesRead), codec);
        if (!codec) {
            codec = QTextCodec::codecForLocale();
            writeConverterState.flags |= QTextCodec::IgnoreHeader;
        }
    }
#if defined (QTEXTSTREAM_DEBUG)
    qDebug("QTextStreamPrivate::fillReadBuffer(), using %s codec",
           codec->name().constData());
#endif
#endif

#if defined (QTEXTSTREAM_DEBUG)
    qDebug("QTextStreamPrivate::fillReadBuffer(), device->read(\"%s\", %d) == %d",
           qt_prettyDebug(buf, qMin(32,int(bytesRead)) , int(bytesRead)).constData(), sizeof(buf), int(bytesRead));
#endif

    if (bytesRead <= 0)
        return false;

    int oldReadBufferSize = readBuffer.size();
#ifndef QT_NO_TEXTCODEC
    // convert to unicode
    readBuffer += codec->toUnicode(buf, bytesRead, &readConverterState);
#else
    readBuffer += QString::fromLatin1(QByteArray(buf, bytesRead).constData());
#endif

    // reset the Text flag.
    if (textModeEnabled)
        device->setTextModeEnabled(true);

    // remove all '\r\n' in the string.
    if (readBuffer.size() > oldReadBufferSize && textModeEnabled) {
        QChar CR = QLatin1Char('\r');
        QChar *writePtr = readBuffer.data() + oldReadBufferSize;
        QChar *readPtr = readBuffer.data() + oldReadBufferSize;
        QChar *endPtr = readBuffer.data() + readBuffer.size();

        int n = oldReadBufferSize;
        if (readPtr < endPtr) {
            // Cut-off to avoid unnecessary self-copying.
            while (*readPtr++ != CR) {
                ++n;
                if (++writePtr == endPtr)
                    break;
            }
        }
        while (readPtr < endPtr) {
            QChar ch = *readPtr++;
            if (ch != CR) {
                *writePtr++ = ch;
            } else {
                if (n < readBufferOffset)
                    --readBufferOffset;
                --bytesRead;
            }
            ++n;
        }
        readBuffer.resize(writePtr - readBuffer.data());
    }

#if defined (QTEXTSTREAM_DEBUG)
    qDebug("QTextStreamPrivate::fillReadBuffer() read %d bytes from device. readBuffer = [%s]", int(bytesRead),
           qt_prettyDebug(readBuffer.toLatin1(), readBuffer.size(), readBuffer.size()).data());
#endif
    return true;
}

flushWriteBuffer()

void QTextStreamPrivate::flushWriteBuffer

(

)

Warning

This function is not part of the public interface.

Definition at line 656 of file qtextstream.cpp.

Referenced by write().

{
    // no buffer next to the QString itself; this function should only
    // be called internally, for devices.
    if (string || !device)
        return;

    // Stream went bye-bye already. Appending further data may succeed again,
    // but would create a corrupted stream anyway.
    if (status != QTextStream::Ok)
        return;

    if (writeBuffer.isEmpty())
        return;

#if defined (Q_OS_WIN)
    // handle text translation and bypass the Text flag in the device.
    bool textModeEnabled = device->isTextModeEnabled();
    if (textModeEnabled) {
        device->setTextModeEnabled(false);
        writeBuffer.replace(QLatin1Char('\n'), QLatin1String("\r\n"));
    }
#endif

#ifndef QT_NO_TEXTCODEC
    if (!codec)
        codec = QTextCodec::codecForLocale();
#if defined (QTEXTSTREAM_DEBUG)
    qDebug("QTextStreamPrivate::flushWriteBuffer(), using %s codec (%s generating BOM)",
           codec->name().constData(), writeConverterState.flags & QTextCodec::IgnoreHeader ? "not" : "");
#endif

    // convert from unicode to raw data
    QByteArray data = codec->fromUnicode(writeBuffer.data(), writeBuffer.size(), &writeConverterState);
#else
    QByteArray data = writeBuffer.toLocal8Bit();
#endif
    writeBuffer.clear();

    // write raw data to the device
    qint64 bytesWritten = device->write(data);
#if defined (QTEXTSTREAM_DEBUG)
    qDebug("QTextStreamPrivate::flushWriteBuffer(), device->write(\"%s\") == %d",
           qt_prettyDebug(data.constData(), qMin(data.size(),32), data.size()).constData(), int(bytesWritten));
#endif
    if (bytesWritten <= 0) {
        status = QTextStream::WriteFailed;
        return;
    }

#if defined (Q_OS_WIN)
    // replace the text flag
    if (textModeEnabled)
        device->setTextModeEnabled(true);
#endif

    // flush the file
#ifndef QT_NO_QOBJECT
    QFile *file = qobject_cast<QFile *>(device);
    bool flushed = !file || file->flush();
#else
    bool flushed = true;
#endif

#if defined (QTEXTSTREAM_DEBUG)
    qDebug("QTextStreamPrivate::flushWriteBuffer() wrote %d bytes",
           int(bytesWritten));
#endif
    if (!flushed || bytesWritten != qint64(data.size()))
        status = QTextStream::WriteFailed;
}

getChar()

bool QTextStreamPrivate::getChar ( QChar *  ch )

inline

Warning

This function is not part of the public interface.

Definition at line 948 of file qtextstream.cpp.

{
    if ((string && stringOffset == string->size())
        || (device && readBuffer.isEmpty() && !fillReadBuffer())) {
        if (ch)
            *ch = 0;
        return false;
    }
    if (ch)
        *ch = *readPtr();
    consume(1);
    return true;
}

getNumber()

QTextStreamPrivate::NumberParsingStatus QTextStreamPrivate::getNumber

(

qulonglong *

ret

)

Warning

This function is not part of the public interface.

Definition at line 1731 of file qtextstream.cpp.

{
    scan(0, 0, 0, NotSpace);
    consumeLastToken();

    // detect int encoding
    int base = integerBase;
    if (base == 0) {
        QChar ch;
        if (!getChar(&ch))
            return npsInvalidPrefix;
        if (ch == QLatin1Char('0')) {
            QChar ch2;
            if (!getChar(&ch2)) {
                // Result is the number 0
                *ret = 0;
                return npsOk;
            }
            ch2 = ch2.toLower();

            if (ch2 == QLatin1Char('x')) {
                base = 16;
            } else if (ch2 == QLatin1Char('b')) {
                base = 2;
            } else if (ch2.isDigit() && ch2.digitValue() >= 0 && ch2.digitValue() <= 7) {
                base = 8;
            } else {
                base = 10;
            }
            ungetChar(ch2);
        } else if (ch == locale.negativeSign() || ch == locale.positiveSign() || ch.isDigit()) {
            base = 10;
        } else {
            ungetChar(ch);
            return npsInvalidPrefix;
        }
        ungetChar(ch);
        // State of the stream is now the same as on entry
        // (cursor is at prefix),
        // and local variable 'base' has been set appropriately.
    }

    qulonglong val=0;
    switch (base) {
    case 2: {
        QChar pf1, pf2, dig;
        // Parse prefix '0b'
        if (!getChar(&pf1) || pf1 != QLatin1Char('0'))
            return npsInvalidPrefix;
        if (!getChar(&pf2) || pf2.toLower() != QLatin1Char('b'))
            return npsInvalidPrefix;
        // Parse digits
        int ndigits = 0;
        while (getChar(&dig)) {
            int n = dig.toLower().unicode();
            if (n == '0' || n == '1') {
                val <<= 1;
                val += n - '0';
            } else {
                ungetChar(dig);
                break;
            }
            ndigits++;
        }
        if (ndigits == 0) {
            // Unwind the prefix and abort
            ungetChar(pf2);
            ungetChar(pf1);
            return npsMissingDigit;
        }
        break;
    }
    case 8: {
        QChar pf, dig;
        // Parse prefix '0'
        if (!getChar(&pf) || pf != QLatin1Char('0'))
            return npsInvalidPrefix;
        // Parse digits
        int ndigits = 0;
        while (getChar(&dig)) {
            int n = dig.toLower().unicode();
            if (n >= '0' && n <= '7') {
                val *= 8;
                val += n - '0';
            } else {
                ungetChar(dig);
                break;
            }
            ndigits++;
        }
        if (ndigits == 0) {
            // Unwind the prefix and abort
            ungetChar(pf);
            return npsMissingDigit;
        }
        break;
    }
    case 10: {
        // Parse sign (or first digit)
        QChar sign;
        int ndigits = 0;
        if (!getChar(&sign))
            return npsMissingDigit;
        if (sign != locale.negativeSign() && sign != locale.positiveSign()) {
            if (!sign.isDigit()) {
                ungetChar(sign);
                return npsMissingDigit;
            }
            val += sign.digitValue();
            ndigits++;
        }
        // Parse digits
        QChar ch;
        while (getChar(&ch)) {
            if (ch.isDigit()) {
                val *= 10;
                val += ch.digitValue();
            } else if (locale != QLocale::c() && ch == locale.groupSeparator()) {
                continue;
            } else {
                ungetChar(ch);
                break;
            }
            ndigits++;
        }
        if (ndigits == 0)
            return npsMissingDigit;
        if (sign == locale.negativeSign()) {
            qlonglong ival = qlonglong(val);
            if (ival > 0)
                ival = -ival;
            val = qulonglong(ival);
        }
        break;
    }
    case 16: {
        QChar pf1, pf2, dig;
        // Parse prefix ' 0x'
        if (!getChar(&pf1) || pf1 != QLatin1Char('0'))
            return npsInvalidPrefix;
        if (!getChar(&pf2) || pf2.toLower() != QLatin1Char('x'))
            return npsInvalidPrefix;
        // Parse digits
        int ndigits = 0;
        while (getChar(&dig)) {
            int n = dig.toLower().unicode();
            if (n >= '0' && n <= '9') {
                val <<= 4;
                val += n - '0';
            } else if (n >= 'a' && n <= 'f') {
                val <<= 4;
                val += 10 + (n - 'a');
            } else {
                ungetChar(dig);
                break;
            }
            ndigits++;
        }
        if (ndigits == 0) {
            return npsMissingDigit;
        }
        break;
    }
    default:
        // Unsupported integerBase
        return npsInvalidPrefix;
    }

    if (ret)
        *ret = val;
    return npsOk;
}

getReal()

bool QTextStreamPrivate::getReal

(

double *

f

)

Warning

This function is not part of the public interface. (hihi)

Definition at line 1907 of file qtextstream.cpp.

{
    // We use a table-driven FSM to parse floating point numbers
    // strtod() cannot be used directly since we may be reading from a
    // QIODevice.
    enum ParserState {
        Init = 0,
        Sign = 1,
        Mantissa = 2,
        Dot = 3,
        Abscissa = 4,
        ExpMark = 5,
        ExpSign = 6,
        Exponent = 7,
        Nan1 = 8,
        Nan2 = 9,
        Inf1 = 10,
        Inf2 = 11,
        NanInf = 12,
        Done = 13
    };
    enum InputToken {
        None = 0,
        InputSign = 1,
        InputDigit = 2,
        InputDot = 3,
        InputExp = 4,
        InputI = 5,
        InputN = 6,
        InputF = 7,
        InputA = 8,
        InputT = 9
    };

    static const uchar table[13][10] = {
        // None InputSign InputDigit InputDot InputExp InputI    InputN    InputF    InputA    InputT
        { 0,    Sign,     Mantissa,  Dot,     0,       Inf1,     Nan1,     0,        0,        0      }, // 0  Init
        { 0,    0,        Mantissa,  Dot,     0,       Inf1,     Nan1,     0,        0,        0      }, // 1  Sign
        { Done, Done,     Mantissa,  Dot,     ExpMark, 0,        0,        0,        0,        0      }, // 2  Mantissa
        { 0,    0,        Abscissa,  0,       0,       0,        0,        0,        0,        0      }, // 3  Dot
        { Done, Done,     Abscissa,  Done,    ExpMark, 0,        0,        0,        0,        0      }, // 4  Abscissa
        { 0,    ExpSign,  Exponent,  0,       0,       0,        0,        0,        0,        0      }, // 5  ExpMark
        { 0,    0,        Exponent,  0,       0,       0,        0,        0,        0,        0      }, // 6  ExpSign
        { Done, Done,     Exponent,  Done,    Done,    0,        0,        0,        0,        0      }, // 7  Exponent
        { 0,    0,        0,         0,       0,       0,        0,        0,        Nan2,     0      }, // 8  Nan1
        { 0,    0,        0,         0,       0,       0,        NanInf,   0,        0,        0      }, // 9  Nan2
        { 0,    0,        0,         0,       0,       0,        Inf2,     0,        0,        0      }, // 10 Inf1
        { 0,    0,        0,         0,       0,       0,        0,        NanInf,   0,        0      }, // 11 Inf2
        { Done, 0,        0,         0,       0,       0,        0,        0,        0,        0      }, // 11 NanInf
    };

    ParserState state = Init;
    InputToken input = None;

    scan(0, 0, 0, NotSpace);
    consumeLastToken();

    const int BufferSize = 128;
    char buf[BufferSize];
    int i = 0;

    QChar c;
    while (getChar(&c)) {
        switch (c.unicode()) {
        case '0': case '1': case '2': case '3': case '4':
        case '5': case '6': case '7': case '8': case '9':
            input = InputDigit;
            break;
        case 'i': case 'I':
            input = InputI;
            break;
        case 'n': case 'N':
            input = InputN;
            break;
        case 'f': case 'F':
            input = InputF;
            break;
        case 'a': case 'A':
            input = InputA;
            break;
        case 't': case 'T':
            input = InputT;
            break;
        default: {
            QChar lc = c.toLower();
            if (lc == locale.decimalPoint().toLower())
                input = InputDot;
            else if (lc == locale.exponential().toLower())
                input = InputExp;
            else if (lc == locale.negativeSign().toLower()
                     || lc == locale.positiveSign().toLower())
                input = InputSign;
            else if (locale != QLocale::c() // backward-compatibility
                     && lc == locale.groupSeparator().toLower())
                input = InputDigit; // well, it isn't a digit, but no one cares.
            else
                input = None;
        }
            break;
        }

        state = ParserState(table[state][input]);

        if  (state == Init || state == Done || i > (BufferSize - 5)) {
            ungetChar(c);
            if (i > (BufferSize - 5)) { // ignore rest of digits
                while (getChar(&c)) {
                    if (!c.isDigit()) {
                        ungetChar(c);
                        break;
                    }
                }
            }
            break;
        }

        buf[i++] = c.toLatin1();
    }

    if (i == 0)
        return false;
    if (!f)
        return true;
    buf[i] = '\0';

    // backward-compatibility. Old implementation supported +nan/-nan
    // for some reason. QLocale only checks for lower-case
    // nan/+inf/-inf, so here we also check for uppercase and mixed
    // case versions.
    if (!qstricmp(buf, "nan") || !qstricmp(buf, "+nan") || !qstricmp(buf, "-nan")) {
        *f = qSNaN();
        return true;
    } else if (!qstricmp(buf, "+inf") || !qstricmp(buf, "inf")) {
        *f = qInf();
        return true;
    } else if (!qstricmp(buf, "-inf")) {
        *f = -qInf();
        return true;
    }
    bool ok;
    *f = locale.toDouble(QString::fromLatin1(buf), &ok);
    return ok;
}

putNumber()

void QTextStreamPrivate::putNumber	(	qulonglong	number,
		bool	negative
	)

Warning

This function is not part of the public interface.

Definition at line 2341 of file qtextstream.cpp.

{
    QString result;

    unsigned flags = 0;
    if (numberFlags & QTextStream::ShowBase)
        flags |= QLocalePrivate::ShowBase;
    if (numberFlags & QTextStream::ForceSign)
        flags |= QLocalePrivate::AlwaysShowSign;
    if (numberFlags & QTextStream::UppercaseBase)
        flags |= QLocalePrivate::UppercaseBase;
    if (numberFlags & QTextStream::UppercaseDigits)
        flags |= QLocalePrivate::CapitalEorX;

    // add thousands group separators. For backward compatibility we
    // don't add a group separator for C locale.
    if (locale != QLocale::c())
        flags |= QLocalePrivate::ThousandsGroup;

    const QLocalePrivate *dd = locale.d();
    int base = integerBase ? integerBase : 10;
    if (negative && base == 10) {
        result = dd->longLongToString(-static_cast<qlonglong>(number), -1,
                                      base, -1, flags);
    } else if (negative) {
        // Workaround for backward compatibility for writing negative
        // numbers in octal and hex:
        // QTextStream(result) << showbase << hex << -1 << oct << -1
        // should output: -0x1 -0b1
        result = dd->unsLongLongToString(number, -1, base, -1, flags);
        result.prepend(locale.negativeSign());
    } else {
        result = dd->unsLongLongToString(number, -1, base, -1, flags);
        // workaround for backward compatibility - in octal form with
        // ShowBase flag set zero should be written as '00'
        if (number == 0 && base == 8 && numberFlags & QTextStream::ShowBase
            && result == QLatin1String("0")) {
            result.prepend(QLatin1Char('0'));
        }
    }
    putString(result, true);
}

putString()

void QTextStreamPrivate::putString ( const QString &  s, bool  number = false  )

inline

Warning

This function is not part of the public interface.

Definition at line 984 of file qtextstream.cpp.

{
    QString tmp = s;

    // handle padding
    int padSize = fieldWidth - s.size();
    if (padSize > 0) {
        QString pad(padSize, padChar);
        if (fieldAlignment == QTextStream::AlignLeft) {
            tmp.append(QString(padSize, padChar));
        } else if (fieldAlignment == QTextStream::AlignRight
                   || fieldAlignment == QTextStream::AlignAccountingStyle) {
            tmp.prepend(QString(padSize, padChar));
            if (fieldAlignment == QTextStream::AlignAccountingStyle && number) {
                const QChar sign = s.size() > 0 ? s.at(0) : QChar();
                if (sign == locale.negativeSign() || sign == locale.positiveSign()) {
                    QChar *data = tmp.data();
                    data[padSize] = tmp.at(0);
                    data[0] = sign;
                }
           }
        } else if (fieldAlignment == QTextStream::AlignCenter) {
            tmp.prepend(QString(padSize/2, padChar));
            tmp.append(QString(padSize - padSize/2, padChar));
        }
    }

#if defined (QTEXTSTREAM_DEBUG)
    QByteArray a = s.toUtf8();
    QByteArray b = tmp.toUtf8();
    qDebug("QTextStreamPrivate::putString(\"%s\") calls write(\"%s\")",
           qt_prettyDebug(a.constData(), a.size(), qMax(16, a.size())).constData(),
           qt_prettyDebug(b.constData(), b.size(), qMax(16, b.size())).constData());
#endif
    write(tmp);
}

read()

QString QTextStreamPrivate::read

(

int

maxlen

)

Definition at line 728 of file qtextstream.cpp.

{
    QString ret;
    if (string) {
        lastTokenSize = qMin(maxlen, string->size() - stringOffset);
        ret = string->mid(stringOffset, lastTokenSize);
    } else {
        while (readBuffer.size() - readBufferOffset < maxlen && fillReadBuffer()) ;
        lastTokenSize = qMin(maxlen, readBuffer.size() - readBufferOffset);
        ret = readBuffer.mid(readBufferOffset, lastTokenSize);
    }
    consumeLastToken();

#if defined (QTEXTSTREAM_DEBUG)
    qDebug("QTextStreamPrivate::read() maxlen = %d, token length = %d", maxlen, ret.length());
#endif
    return ret;
}

readPtr()

const QChar * QTextStreamPrivate::readPtr ( ) const

inline

Warning

This function is not part of the public interface.

Definition at line 853 of file qtextstream.cpp.

Referenced by fillReadBuffer(), getChar(), and scan().

{
    Q_ASSERT(readBufferOffset <= readBuffer.size());
    if (string)
        return string->constData() + stringOffset;
    return readBuffer.constData() + readBufferOffset;
}

reset()

void QTextStreamPrivate::reset

(

)

Warning

This function is not part of the public interface.

Definition at line 498 of file qtextstream.cpp.

Referenced by QTextStreamPrivate().

{
    realNumberPrecision = 6;
    integerBase = 0;
    fieldWidth = 0;
    padChar = QLatin1Char(' ');
    fieldAlignment = QTextStream::AlignRight;
    realNumberNotation = QTextStream::SmartNotation;
    numberFlags = 0;

    device = 0;
    deleteDevice = false;
    string = 0;
    stringOffset = 0;
    stringOpenMode = QIODevice::NotOpen;

    readBufferOffset = 0;
    readBufferStartDevicePos = 0;
    lastTokenSize = 0;

#ifndef QT_NO_TEXTCODEC
    codec = QTextCodec::codecForLocale();
    resetCodecConverterStateHelper(&readConverterState);
    resetCodecConverterStateHelper(&writeConverterState);
    delete readConverterSavedState;
    readConverterSavedState = 0;
    writeConverterState.flags |= QTextCodec::IgnoreHeader;
    autoDetectUnicode = true;
#endif
}

resetReadBuffer()

void QTextStreamPrivate::resetReadBuffer

(

)

Warning

This function is not part of the public interface.

Definition at line 647 of file qtextstream.cpp.

{
    readBuffer.clear();
    readBufferOffset = 0;
    readBufferStartDevicePos = (device ? device->pos() : 0);
}

restoreToSavedConverterState()

void QTextStreamPrivate::restoreToSavedConverterState ( )

inline

Warning

This function is not part of the public interface.

Definition at line 917 of file qtextstream.cpp.

Referenced by QTextStream::pos().

{
#ifndef QT_NO_TEXTCODEC
    if (readConverterSavedState) {
        // we have a saved state
        // that means the converter can be copied
        copyConverterStateHelper(&readConverterState, readConverterSavedState);
    } else {
        // the only state we could save was the initial
        // so reset to that
        resetCodecConverterStateHelper(&readConverterState);
    }
#endif
}

saveConverterState()

void QTextStreamPrivate::saveConverterState ( qint64  newPos )

inline

Warning

This function is not part of the public interface.

Definition at line 897 of file qtextstream.cpp.

Referenced by consume().

{
#ifndef QT_NO_TEXTCODEC
    if (readConverterState.d) {
        // converter cannot be copied, so don't save anything
        // don't update readBufferStartDevicePos either
        return;
    }

    if (!readConverterSavedState)
        readConverterSavedState = new QTextCodec::ConverterState;
    copyConverterStateHelper(readConverterSavedState, &readConverterState);
#endif

    readBufferStartDevicePos = newPos;
    readConverterSavedStateOffset = 0;
}

scan()

bool QTextStreamPrivate::scan	(	const QChar **	ptr,
		int *	length,
		int	maxlen,
		TokenDelimiter	delimiter
	)

Scans no more than maxlen QChars in the current buffer for the first delimiter.

Warning

This function is not part of the public interface.

Stores a pointer to the start offset of the token in ptr, and the length in QChars in length.

Definition at line 756 of file qtextstream.cpp.

{
    int totalSize = 0;
    int delimSize = 0;
    bool consumeDelimiter = false;
    bool foundToken = false;
    int startOffset = device ? readBufferOffset : stringOffset;
    QChar lastChar;

    bool canStillReadFromDevice = true;
    do {
        int endOffset;
        const QChar *chPtr;
        if (device) {
            chPtr = readBuffer.constData();
            endOffset = readBuffer.size();
        } else {
            chPtr = string->constData();
            endOffset = string->size();
        }
        chPtr += startOffset;

        for (; !foundToken && startOffset < endOffset && (!maxlen || totalSize < maxlen); ++startOffset) {
            const QChar ch = *chPtr++;
            ++totalSize;

            switch (delimiter) {
            case Space:
                if (ch.isSpace()) {
                    foundToken = true;
                    delimSize = 1;
                }
                break;
            case NotSpace:
                if (!ch.isSpace()) {
                    foundToken = true;
                    delimSize = 1;
                }
                break;
            case EndOfLine:
                if (ch == QLatin1Char('\n')) {
                    foundToken = true;
                    delimSize = (lastChar == QLatin1Char('\r')) ? 2 : 1;
                    consumeDelimiter = true;
                }
                lastChar = ch;
                break;
            }
        }
    } while (!foundToken
             && (!maxlen || totalSize < maxlen)
             && (device && (canStillReadFromDevice = fillReadBuffer())));

    // if the token was not found, but we reached the end of input,
    // then we accept what we got. if we are not at the end of input,
    // we return false.
    if (!foundToken && (!maxlen || totalSize < maxlen)
        && (totalSize == 0
            || (string && stringOffset + totalSize < string->size())
            || (device && !device->atEnd() && canStillReadFromDevice))) {
#if defined (QTEXTSTREAM_DEBUG)
        qDebug("QTextStreamPrivate::scan() did not find the token.");
#endif
        return false;
    }

    // if we find a '\r' at the end of the data when reading lines,
    // don't make it part of the line.
    if (delimiter == EndOfLine && totalSize > 0 && !foundToken) {
        if (((string && stringOffset + totalSize == string->size()) || (device && device->atEnd()))
            && lastChar == QLatin1Char('\r')) {
            consumeDelimiter = true;
            ++delimSize;
        }
    }

    // set the read offset and length of the token
    if (length)
        *length = totalSize - delimSize;
    if (ptr)
        *ptr = readPtr();

    // update last token size. the callee will call consumeLastToken() when
    // done.
    lastTokenSize = totalSize;
    if (!consumeDelimiter)
        lastTokenSize -= delimSize;

#if defined (QTEXTSTREAM_DEBUG)
    qDebug("QTextStreamPrivate::scan(%p, %p, %d, %x) token length = %d, delimiter = %d",
           ptr, length, maxlen, (int)delimiter, totalSize - delimSize, delimSize);
#endif
    return true;
}

ungetChar()

void QTextStreamPrivate::ungetChar ( const QChar &  ch )

inline

Warning

This function is not part of the public interface.

Definition at line 964 of file qtextstream.cpp.

{
    if (string) {
        if (stringOffset == 0)
            string->prepend(ch);
        else
            (*string)[--stringOffset] = ch;
        return;
    }

    if (readBufferOffset == 0) {
        readBuffer.prepend(ch);
        return;
    }

    readBuffer[--readBufferOffset] = ch;
}

write()

void QTextStreamPrivate::write ( const QString &  data )

inline

Warning

This function is not part of the public interface.

Definition at line 934 of file qtextstream.cpp.

Referenced by putString().

{
    if (string) {
        // ### What about seek()??
        string->append(data);
    } else {
        writeBuffer += data;
        if (writeBuffer.size() > QTEXTSTREAM_BUFFERSIZE)
            flushWriteBuffer();
    }
}

Properties

autoDetectUnicode

bool QTextStreamPrivate::autoDetectUnicode

Definition at line 383 of file qtextstream.cpp.

Referenced by fillReadBuffer(), QTextStream::pos(), and reset().

codec

QTextCodec* QTextStreamPrivate::codec

Definition at line 379 of file qtextstream.cpp.

Referenced by fillReadBuffer(), flushWriteBuffer(), and reset().

deleteDevice

bool QTextStreamPrivate::deleteDevice

Definition at line 370 of file qtextstream.cpp.

Referenced by reset(), and ~QTextStreamPrivate().

device

QIODevice* QTextStreamPrivate::device

Definition at line 366 of file qtextstream.cpp.

Referenced by consume(), fillReadBuffer(), flushWriteBuffer(), getChar(), reset(), resetReadBuffer(), scan(), and ~QTextStreamPrivate().

deviceClosedNotifier

QDeviceClosedNotifier QTextStreamPrivate::deviceClosedNotifier

Definition at line 368 of file qtextstream.cpp.

fieldAlignment

QTextStream::FieldAlignment QTextStreamPrivate::fieldAlignment

Definition at line 434 of file qtextstream.cpp.

Referenced by putString(), and reset().

fieldWidth

int QTextStreamPrivate::fieldWidth

Definition at line 432 of file qtextstream.cpp.

Referenced by putString(), and reset().

integerBase

int QTextStreamPrivate::integerBase

Definition at line 431 of file qtextstream.cpp.

Referenced by reset().

lastTokenSize

int QTextStreamPrivate::lastTokenSize

Definition at line 401 of file qtextstream.cpp.

Referenced by consumeLastToken(), read(), reset(), and scan().

locale

QLocale QTextStreamPrivate::locale

Definition at line 441 of file qtextstream.cpp.

Referenced by putString().

numberFlags

QTextStream::NumberFlags QTextStreamPrivate::numberFlags

Definition at line 436 of file qtextstream.cpp.

Referenced by reset().

padChar

QChar QTextStreamPrivate::padChar

Definition at line 433 of file qtextstream.cpp.

Referenced by putString(), and reset().

q_ptr

QTextStream* QTextStreamPrivate::q_ptr

Definition at line 443 of file qtextstream.cpp.

Referenced by QTextStreamPrivate().

readBuffer

QString QTextStreamPrivate::readBuffer

Definition at line 424 of file qtextstream.cpp.

Referenced by consume(), fillReadBuffer(), getChar(), QTextStream::pos(), read(), readPtr(), resetReadBuffer(), scan(), and ungetChar().

readBufferOffset

int QTextStreamPrivate::readBufferOffset

Definition at line 425 of file qtextstream.cpp.

Referenced by consume(), fillReadBuffer(), QTextStream::pos(), read(), readPtr(), reset(), resetReadBuffer(), scan(), and ungetChar().

readBufferStartDevicePos

qint64 QTextStreamPrivate::readBufferStartDevicePos

Definition at line 427 of file qtextstream.cpp.

Referenced by reset(), resetReadBuffer(), and saveConverterState().

readConverterSavedState

QTextCodec::ConverterState* QTextStreamPrivate::readConverterSavedState

Definition at line 382 of file qtextstream.cpp.

Referenced by reset(), restoreToSavedConverterState(), saveConverterState(), and ~QTextStreamPrivate().

readConverterSavedStateOffset

int QTextStreamPrivate::readConverterSavedStateOffset

Definition at line 426 of file qtextstream.cpp.

Referenced by consume(), QTextStream::pos(), and saveConverterState().

readConverterState

QTextCodec::ConverterState QTextStreamPrivate::readConverterState

Definition at line 380 of file qtextstream.cpp.

Referenced by fillReadBuffer(), reset(), restoreToSavedConverterState(), and saveConverterState().

realNumberNotation

QTextStream::RealNumberNotation QTextStreamPrivate::realNumberNotation

Definition at line 435 of file qtextstream.cpp.

Referenced by reset().

realNumberPrecision

int QTextStreamPrivate::realNumberPrecision

Definition at line 430 of file qtextstream.cpp.

Referenced by reset().

status

QTextStream::Status QTextStreamPrivate::status

Definition at line 439 of file qtextstream.cpp.

Referenced by flushWriteBuffer().

string

QString* QTextStreamPrivate::string

Definition at line 373 of file qtextstream.cpp.

Referenced by consume(), getChar(), read(), and scan().

stringOffset

int QTextStreamPrivate::stringOffset

Definition at line 374 of file qtextstream.cpp.

Referenced by consume(), getChar(), read(), readPtr(), reset(), scan(), and ungetChar().

stringOpenMode

QIODevice::OpenMode QTextStreamPrivate::stringOpenMode

Definition at line 375 of file qtextstream.cpp.

Referenced by reset().

writeBuffer

QString QTextStreamPrivate::writeBuffer

Definition at line 423 of file qtextstream.cpp.

Referenced by flushWriteBuffer(), and write().

writeConverterState

QTextCodec::ConverterState QTextStreamPrivate::writeConverterState

Definition at line 381 of file qtextstream.cpp.

Referenced by fillReadBuffer(), flushWriteBuffer(), and reset().

---

The documentation for this class was generated from the following file:

• /src/corelib/io/qtextstream.cpp