QTextStream Class Reference

The QTextStream class provides basic functions for reading and writing text using a QIODevice. More...

#include <qtextstream.h>

Inheritance diagram for QTextStream:

Public Types
enum	Encoding {   Locale, Latin1, Unicode, UnicodeNetworkOrder,   UnicodeReverse, RawUnicode, UnicodeUTF8 }
enum	{   skipws = 0x0001, left = 0x0002, right = 0x0004, internal = 0x0008,   bin = 0x0010, oct = 0x0020, dec = 0x0040, hex = 0x0080,   showbase = 0x0100, showpoint = 0x0200, uppercase = 0x0400, showpos = 0x0800,   scientific = 0x1000, fixed = 0x2000 }

Public Member Functions
void	setEncoding (Encoding)
void	setCodec (QTextCodec *)
	QTextStream ()
	QTextStream (QIODevice *)
	QTextStream (QString *, int mode)
	QTextStream (QString &, int mode)
	QTextStream (QByteArray, int mode)
	QTextStream (FILE *, int mode)
virtual	~QTextStream ()
QIODevice *	device () const
void	setDevice (QIODevice *)
void	unsetDevice ()
bool	atEnd () const
bool	eof () const
QTextStream &	operator>> (QChar &)
QTextStream &	operator>> (char &)
QTextStream &	operator>> (signed short &)
QTextStream &	operator>> (unsigned short &)
QTextStream &	operator>> (signed int &)
QTextStream &	operator>> (unsigned int &)
QTextStream &	operator>> (signed long &)
QTextStream &	operator>> (unsigned long &)
QTextStream &	operator>> (float &)
QTextStream &	operator>> (double &)
QTextStream &	operator>> (char *)
QTextStream &	operator>> (QString &)
QTextStream &	operator>> (QCString &)
QTextStream &	operator<< (QChar)
QTextStream &	operator<< (char)
QTextStream &	operator<< (signed short)
QTextStream &	operator<< (unsigned short)
QTextStream &	operator<< (signed int)
QTextStream &	operator<< (unsigned int)
QTextStream &	operator<< (signed long)
QTextStream &	operator<< (unsigned long)
QTextStream &	operator<< (float)
QTextStream &	operator<< (double)
QTextStream &	operator<< (const char *)
QTextStream &	operator<< (const QString &)
QTextStream &	operator<< (const QCString &)
QTextStream &	operator<< (void *)
QTextStream &	readRawBytes (char *, uint len)
QTextStream &	writeRawBytes (const char *, uint len)
QString	readLine ()
QString	read ()
void	skipWhiteSpace ()
int	flags () const
int	flags (int f)
int	setf (int bits)
int	setf (int bits, int mask)
int	unsetf (int bits)
void	reset ()
int	width () const
int	width (int)
int	fill () const
int	fill (int)
int	precision () const
int	precision (int)

Static Public Attributes
static const int	basefield = I_BASE_MASK
static const int	adjustfield
static const int	floatfield

Private Member Functions
long	input_int ()
void	init ()
QTextStream &	output_int (int, ulong, bool)
bool	isNetworkOrder ()
QChar	eat_ws ()
void	ts_ungetc (QChar)
QChar	ts_getc ()
uint	ts_getbuf (QChar *, uint)
void	ts_putc (int)
void	ts_putc (QChar)
bool	ts_isspace (QChar)
bool	ts_isdigit (QChar)
ulong	input_bin ()
ulong	input_oct ()
ulong	input_dec ()
ulong	input_hex ()
double	input_double ()
QTextStream &	writeBlock (const char *p, uint len)
QTextStream &	writeBlock (const QChar *p, uint len)
	QTextStream (const QTextStream &)
QTextStream &	operator= (const QTextStream &)

Private Attributes
QIODevice *	dev
int	fflags
int	fwidth
int	fillchar
int	fprec
bool	fstrm
bool	owndev
QTextCodec *	mapper
QTextStreamPrivate *	d
QChar	ungetcBuf
bool	latin1
bool	internalOrder
bool	doUnicodeHeader
void *	reserved_ptr

Detailed Description

The QTextStream class provides basic functions for reading and writing text using a QIODevice.

endl bin oct dec hex flush ws

The text stream class has a functional interface that is very similar to that of the standard C++ iostream class. The difference between iostream and QTextStream is that our stream operates on a QIODevice, which is easily subclassed, while iostream operates on FILE * pointers, which can not be subclassed.

Qt provides several global functions similar to the ones in iostream:

• bin sets the QTextStream to read/write binary numbers
• oct sets the QTextStream to read/write octal numbers
• dec sets the QTextStream to read/write decimal numbers
• hex sets the QTextStream to read/write hexadecimal numbers
• endl forces a line break
• flush forces the QIODevice to flush any buffered data
• ws eats any available white space (on input)
• reset resets the QTextStream to its default mode (see reset()).

Warning

By default, QTextStream will automatically detect whether integers in the stream are in decimal, octal, hexadecimal or binary format when reading from the stream. In particular, a leading '0' signifies octal, ie. the sequence "0100" will be interpreted as 64.

The QTextStream class reads and writes text and it is not appropriate for dealing with binary data (but QDataStream is).

By default output of Unicode text (ie. QString) is done using the local 8-bit encoding. This can be changed using the setEncoding() method. For input, the QTextStream will auto-detect standard Unicode "byte order marked" text files, but otherwise the local 8-bit encoding is used.

See also

QDataStream

Definition at line 53 of file qtextstream.h.

Member Enumeration Documentation

anonymous enum

Enumerator
skipws
left
right
internal
bin
oct
dec
hex
showbase
showpoint
uppercase
showpos
scientific
fixed

Definition at line 117 of file qtextstream.h.

         {
        skipws    = 0x0001,                     // skip whitespace on input
        left      = 0x0002,                     // left-adjust output
        right     = 0x0004,                     // right-adjust output
        internal  = 0x0008,                     // pad after sign
        bin       = 0x0010,                     // binary format integer
        oct       = 0x0020,                     // octal format integer
        dec       = 0x0040,                     // decimal format integer
        hex       = 0x0080,                     // hex format integer
        showbase  = 0x0100,                     // show base indicator
        showpoint = 0x0200,                     // force decimal point (float)
        uppercase = 0x0400,                     // upper-case hex output
        showpos   = 0x0800,                     // add '+' to positive integers
        scientific= 0x1000,                     // scientific float output
        fixed     = 0x2000                      // fixed float output
    };

enum QTextStream::Encoding

Enumerator
Locale
Latin1
Unicode
UnicodeNetworkOrder
UnicodeReverse
RawUnicode
UnicodeUTF8

Definition at line 56 of file qtextstream.h.

                  { Locale, Latin1, Unicode, UnicodeNetworkOrder,
                    UnicodeReverse, RawUnicode, UnicodeUTF8 };

Constructor & Destructor Documentation

QTextStream::QTextStream

(

)

Constructs a data stream that has no IO device.

Definition at line 235 of file qtextstream.cpp.

{
    init();
    setEncoding( Locale ); //###
    reset();
    d->sourceType = QTextStreamPrivate::NotSet;
}

QTextStream::QTextStream

(

QIODevice *

iod

)

Constructs a text stream that uses the IO device iod.

Definition at line 247 of file qtextstream.cpp.

{
    init();
    setEncoding( Locale ); //###
    dev = iod;                                  // set device
    reset();
    d->sourceType = QTextStreamPrivate::IODevice;
}

QTextStream::QTextStream	(	QString *	str,
		int	filemode
	)

Constructs a text stream that operates on a Unicode QString through an internal device.

If you set an encoding or codec with setEncoding() or setCodec(), this setting is ignored for text streams that operate on QString.

Example:

QString str;
QTextStream ts( &str, IO_WriteOnly );
ts << "pi = " << 3.14;                        // str == "pi = 3.14"

Writing data to the text stream will modify the contents of the string. The string will be expanded when data is written beyond the end of the string. Note that the string will not be truncated:

QString str = "pi = 3.14";
QTextStream ts( &str, IO_WriteOnly );
ts <<  "2+2 = " << 2+2;               // str == "2+2 = 414"

Note that since QString is Unicode, you should not use readRawBytes() or writeRawBytes() on such a stream.

Definition at line 494 of file qtextstream.cpp.

{
    // TODO: optimize for this case as it becomes more common
    //        (see QStringBuffer above)
    init();
    dev = new QStringBuffer( str );
    ((QStringBuffer *)dev)->open( filemode );
    owndev = TRUE;
    setEncoding(RawUnicode);
    reset();
    d->sourceType = QTextStreamPrivate::String;
}

QTextStream::QTextStream	(	QString &	str,
		int	filemode
	)

This constructor is equivalent to the constructor taking a QString* parameter.

Definition at line 513 of file qtextstream.cpp.

{
    init();
    dev = new QStringBuffer( &str );
    ((QStringBuffer *)dev)->open( filemode );
    owndev = TRUE;
    setEncoding(RawUnicode);
    reset();
    d->sourceType = QTextStreamPrivate::String;
}

QTextStream::QTextStream	(	QByteArray	a,
		int	mode
	)

Constructs a text stream that operates on a byte array through an internal QBuffer device.

Example:

QByteArray array;
QTextStream ts( array, IO_WriteOnly );
ts << "pi = " << 3.14 << '\0';                // array == "pi = 3.14"

Writing data to the text stream will modify the contents of the array. The array will be expanded when data is written beyond the end of the string.

Same example, using a QBuffer:

QByteArray array;
QBuffer buf( array );
buf.open( IO_WriteOnly );
QTextStream ts( &buf );
ts << "pi = " << 3.14 << '\0';                // array == "pi = 3.14"
buf.close();

Definition at line 550 of file qtextstream.cpp.

{
    init();
    dev = new QBuffer( a );
    ((QBuffer *)dev)->open( mode );
    owndev = TRUE;
    setEncoding( Locale ); //### Locale???
    reset();
    d->sourceType = QTextStreamPrivate::ByteArray;
}

QTextStream::QTextStream	(	FILE *	fh,
		int	mode
	)

Constructs a text stream that operates on an existing file handle fh through an internal QFile device.

Example:

QTextStream cout( stdout, IO_WriteOnly );
QTextStream cin ( stdin,  IO_ReadOnly );
QTextStream cerr( stderr, IO_WriteOnly );

Definition at line 573 of file qtextstream.cpp.

{
    init();
    setEncoding( Locale ); //###
    dev = new QFile;
    ((QFile *)dev)->open( mode, fh );
    fstrm = owndev = TRUE;
    reset();
    d->sourceType = QTextStreamPrivate::File;
}

QTextStream::~QTextStream ( )

virtual

Destructs the text stream.

The destructor does not affect the current IO device.

Definition at line 590 of file qtextstream.cpp.

{
    if ( owndev )
        delete dev;
    delete d;
}

QTextStream::QTextStream ( const QTextStream &  )

private

Member Function Documentation

bool QTextStream::atEnd ( ) const

inline

Returns TRUE if the IO device has reached the end position (end of stream or file) or if there is no IO device set.

Returns FALSE if the current position of the read/write head of the IO device is somewhere before the end position.

See also

QIODevice::atEnd()

Definition at line 226 of file qtextstream.h.

{ return dev ? dev->atEnd() : FALSE; }

QIODevice * QTextStream::device ( ) const

inline

Returns the IO device currently set.

See also

setDevice(), unsetDevice()

Definition at line 223 of file qtextstream.h.

{ return dev; }

QChar QTextStream::eat_ws ( )

private

Definition at line 212 of file qtextstream.cpp.

{
    QChar c;
    do { c = ts_getc(); } while ( c != QEOF && ts_isspace(c) );
    return c;
}

bool QTextStream::eof ( ) const

inline

This function has been renamed to atEnd().

See also

QIODevice::atEnd()

Definition at line 229 of file qtextstream.h.

{ return atEnd(); }

int QTextStream::fill ( ) const

inline

Returns the fill character. The default value is ' ' (space).

Definition at line 253 of file qtextstream.h.

{ return fillchar; }

int QTextStream::fill ( int  f )

inline

Sets the fill character to f. Returns the previous fill character.

Definition at line 256 of file qtextstream.h.

{ int oldc = fillchar;  fillchar = f;  return oldc;  }

int QTextStream::flags ( ) const

inline

Returns the current stream flags. The default value is 0.

The meaning of the flags are:

• skipws - Not currently used - whitespace always skipped
• left - Numeric fields are left-aligned
• right - Not currently used (by default numerics are right aligned)
• internal - Put any padding spaces between +/- and value
• bin - Output and input only in binary
• oct - Output and input only in octal
• dec - Output and input only in decimal
• hex - Output and input only in hexadecimal
• showbase - Annotate numeric outputs with 0b, 0, or 0x if in bin, oct, or hex format
• showpoint - Not currently used
• uppercase - Use 0B and 0X rather than 0b and 0x
• showpos - Show + for positive numeric values
• scientific - Use scientific notation for floating point values
• fixed - Use fixed-point notation for floating point values

Note that unless bin, oct, dec, or hex is set, the input base is octal if the value starts with 0, hexadecimal if it starts with 0x, binary if the value starts with 0b, and decimal otherwise.

See also

setf(), unsetf()

Definition at line 232 of file qtextstream.h.

{ return fflags; }

int QTextStream::flags ( int  f )

inline

Sets the stream flags to f. Returns the previous stream flags.

See also

setf(), unsetf(), flags()

Definition at line 235 of file qtextstream.h.

{ int oldf = fflags;  fflags = f;  return oldf; }

void QTextStream::init ( )

private

Definition at line 219 of file qtextstream.cpp.

{
    // ### ungetcBuf = QEOF;
    dev = 0;                                    // no device set
    fstrm = owndev = FALSE;
    mapper = 0;
    d = new QTextStreamPrivate;
    doUnicodeHeader = TRUE;      //default to autodetect
    latin1 = TRUE;               // ### should use local?
    internalOrder = QChar::networkOrdered(); //default to network order
}

ulong QTextStream::input_bin ( )

private

Definition at line 1049 of file qtextstream.cpp.

{
    ulong val = 0;
    QChar ch = eat_ws();
    int dv = ch.digitValue();
    while (  dv == 0 || dv == 1 ) {
        val = ( val << 1 ) + dv;
        ch = ts_getc();
        dv = ch.digitValue();
    }
    if ( ch != QEOF )
        ts_ungetc( ch );
    return val;
}

ulong QTextStream::input_dec ( )

private

Definition at line 1083 of file qtextstream.cpp.

{
    ulong val = 0;
    QChar ch = eat_ws();
    int dv = ch.digitValue();
    while ( ts_isdigit(ch) ) {
        val = val * 10 + dv;
        ch = ts_getc();
        dv = ch.digitValue();
    }
    if ( ch != QEOF )
        ts_ungetc( ch );
    return val;
}

double QTextStream::input_double ( )

private

Definition at line 1193 of file qtextstream.cpp.

{
    const int Init       = 0;                   // states
    const int Sign       = 1;
    const int Mantissa   = 2;
    const int Dot        = 3;
    const int Abscissa   = 4;
    const int ExpMark    = 5;
    const int ExpSign    = 6;
    const int Exponent   = 7;
    const int Done       = 8;

    const int InputSign  = 1;                   // input tokens
    const int InputDigit = 2;
    const int InputDot   = 3;
    const int InputExp   = 4;

    static uchar table[8][5] = {
     /* None     InputSign   InputDigit InputDot InputExp */
        { 0,        Sign,     Mantissa,  Dot,      0,      }, // Init
        { 0,        0,        Mantissa,  Dot,      0,      }, // Sign
        { Done,     Done,     Mantissa,  Dot,      ExpMark,}, // Mantissa
        { 0,        0,        Abscissa,  0,        0,      }, // Dot
        { Done,     Done,     Abscissa,  Done,     ExpMark,}, // Abscissa
        { 0,        ExpSign,  Exponent,  0,        0,      }, // ExpMark
        { 0,        0,        Exponent,  0,        0,      }, // ExpSign
        { Done,     Done,     Exponent,  Done,     Done    }  // Exponent
    };

    int state = Init;                           // parse state
    int input;                                  // input token

    char buf[256];
    int i = 0;
    QChar c = eat_ws();

    while ( TRUE ) {

        switch ( c ) {
            case '+':
            case '-':
                input = InputSign;
                break;
            case '0': case '1': case '2': case '3': case '4':
            case '5': case '6': case '7': case '8': case '9':
                input = InputDigit;
                break;
            case '.':
                input = InputDot;
                break;
            case 'e':
            case 'E':
                input = InputExp;
                break;
            default:
                input = 0;
                break;
        }

        state = table[state][input];

        if  ( state == 0 || state == Done || i > 250 ) {
            if ( i > 250 ) {                    // ignore rest of digits
                do { c = ts_getc(); } while ( c != QEOF && ts_isdigit(c) );
            }
            if ( c != QEOF )
                ts_ungetc( c );
            buf[i] = '\0';
            char *end;
            return strtod( buf, &end );
        }

        buf[i++] = c;
        c = ts_getc();
    }

#if !defined(_CC_EGG_)
    return 0.0;
#endif
}

ulong QTextStream::input_hex ( )

private

Definition at line 1098 of file qtextstream.cpp.

{
    ulong val = 0;
    QChar ch = eat_ws();
    char c = ch;
    while ( isxdigit(c) ) {
        val <<= 4;
        if ( ts_isdigit(c) )
            val += c - '0';
        else
            val += 10 + tolower(c) - 'a';
        c = ch = ts_getc();
    }
    if ( ch != QEOF )
        ts_ungetc( ch );
    return val;
}

long QTextStream::input_int ( )

private

Definition at line 1116 of file qtextstream.cpp.

{
    long val;
    QChar ch;
    char c;
    switch ( flags() & basefield ) {
    case bin:
        val = (long)input_bin();
        break;
    case oct:
        val = (long)input_oct();
        break;
    case dec:
        c = ch = eat_ws();
        if ( ch == QEOF ) {
            val = 0;
        } else {
            if ( !(c == '-' || c == '+') )
                ts_ungetc( ch );
            if ( c == '-' ) {
                ulong v = input_dec();
                if ( v ) {              // ensure that LONG_MIN can be read
                    v--;
                    val = -((long)v) - 1;
                } else {
                    val = 0;
                }
            } else {
                val = (long)input_dec();
            }
        }
        break;
    case hex:
        val = (long)input_hex();
        break;
    default:
        val = 0;
        c = ch = eat_ws();
        if ( c == '0' ) {               // bin, oct or hex
            c = ch = ts_getc();
            if ( tolower(c) == 'x' )
                val = (long)input_hex();
            else if ( tolower(c) == 'b' )
                val = (long)input_bin();
            else {                      // octal
                ts_ungetc( ch );
                if ( c >= '0' && c <= '7' ) {
                    val = (long)input_oct();
                } else {
                    val = 0;
                }
            }
        } else if ( ts_isdigit(ch) ) {
            ts_ungetc( ch );
            val = (long)input_dec();
        } else if ( c == '-' || c == '+' ) {
            ulong v = input_dec();
            if ( c == '-' ) {
                if ( v ) {              // ensure that LONG_MIN can be read
                    v--;
                    val = -((long)v) - 1;
                } else {
                    val = 0;
                }
            } else {
                val = (long)v;
            }
        }
    }
    return val;
}

ulong QTextStream::input_oct ( )

private

Definition at line 1064 of file qtextstream.cpp.

{
    ulong val = 0;
    QChar ch = eat_ws();
    int dv = ch.digitValue();
    while ( dv >= 0 && dv <= 7 ) {
        val = ( val << 3 ) + dv;
        ch = ts_getc();
        dv = ch.digitValue();
    }
    if ( dv == 8 || dv == 9 ) {
        while ( ts_isdigit(ch) )
            ch = ts_getc();
    }
    if ( ch != QEOF )
        ts_ungetc( ch );
    return val;
}

bool QTextStream::isNetworkOrder ( )

inlineprivate

Definition at line 158 of file qtextstream.h.

{ return internalOrder == QChar::networkOrdered(); }

QTextStream & QTextStream::operator<<

(

QChar

c

)

Writes a char to the stream and returns a reference to the stream.

The character c is assumed to be Latin1 encoded independent of the Encoding set for the QTextStream.

Definition at line 1575 of file qtextstream.cpp.

{
    CHECK_STREAM_PRECOND
    ts_putc( c );
    return *this;
}

QTextStream & QTextStream::operator<<

(

char

c

)

Writes a char to the stream and returns a reference to the stream.

Definition at line 1585 of file qtextstream.cpp.

{
    CHECK_STREAM_PRECOND
    unsigned char uc = (unsigned char) c;
    ts_putc( uc );
    return *this;
}

QTextStream & QTextStream::operator<<

(

signed short

i

)

Writes a short integer to the stream and returns a reference to the stream.

Definition at line 1700 of file qtextstream.cpp.

{
    return output_int( I_SHORT | I_SIGNED, i, i < 0 );
}

QTextStream & QTextStream::operator<<

(

unsigned short

i

)

Writes an unsigned short integer to the stream and returns a reference to the stream.

Definition at line 1711 of file qtextstream.cpp.

{
    return output_int( I_SHORT | I_UNSIGNED, i, FALSE );
}

QTextStream & QTextStream::operator<<

(

signed int

i

)

Writes an int to the stream and returns a reference to the stream.

Definition at line 1722 of file qtextstream.cpp.

{
    return output_int( I_INT | I_SIGNED, i, i < 0 );
}

QTextStream & QTextStream::operator<<

(

unsigned int

i

)

Writes an unsigned int to the stream and returns a reference to the stream.

Definition at line 1733 of file qtextstream.cpp.

{
    return output_int( I_INT | I_UNSIGNED, i, FALSE );
}

QTextStream & QTextStream::operator<<

(

signed long

i

)

Writes a long int to the stream and returns a reference to the stream.

Definition at line 1744 of file qtextstream.cpp.

{
    return output_int( I_LONG | I_SIGNED, i, i < 0 );
}

QTextStream & QTextStream::operator<<

(

unsigned long

i

)

Writes an unsigned long int to the stream and returns a reference to the stream.

Definition at line 1755 of file qtextstream.cpp.

{
    return output_int( I_LONG | I_UNSIGNED, i, FALSE );
}

QTextStream & QTextStream::operator<<

(

float

f

)

Writes a float to the stream and returns a reference to the stream.

Definition at line 1765 of file qtextstream.cpp.

{
    return *this << (double)f;
}

QTextStream & QTextStream::operator<<

(

double

f

)

Writes a double to the stream and returns a reference to the stream.

Definition at line 1775 of file qtextstream.cpp.

{
    CHECK_STREAM_PRECOND
    char buf[64];
    char f_char;
    char format[16];
    if ( (flags()&floatfield) == fixed )
        f_char = 'f';
    else if ( (flags()&floatfield) == scientific )
        f_char = (flags() & uppercase) ? 'E' : 'e';
    else
        f_char = (flags() & uppercase) ? 'G' : 'g';
    register char *fs = format;                 // generate format string
    *fs++ = '%';                                //   "%.<prec>l<f_char>"
    *fs++ = '.';
    int prec = precision();
    if ( prec > 99 )
        prec = 99;
    if ( prec >= 10 ) {
        *fs++ = prec / 10 + '0';
        *fs++ = prec % 10 + '0';
    } else {
        *fs++ = prec + '0';
    }
    *fs++ = 'l';
    *fs++ = f_char;
    *fs = '\0';
    sprintf( buf, format, f );                  // convert to text
    if ( fwidth )                               // padding
        *this << (const char*)buf;
    else                                        // just write it
        writeBlock( buf, qstrlen(buf) );
    return *this;
}

QTextStream & QTextStream::operator<<

(

const char *

s

)

Writes a string to the stream and returns a reference to the stream.

The string s is assumed to be Latin1 encoded independent of the Encoding set for the QTextStream.

Definition at line 1818 of file qtextstream.cpp.

{
    CHECK_STREAM_PRECOND
    char padbuf[48];
    uint len = qstrlen( s );                    // don't write null terminator
    if ( fwidth ) {                             // field width set
        int padlen = fwidth - len;
        fwidth = 0;                             // reset width
        if ( padlen > 0 ) {
            char *ppad;
            if ( padlen > 46 ) {                // create extra big fill buffer
                ppad = new char[padlen];
                CHECK_PTR( ppad );
            } else {
                ppad = padbuf;
            }
            memset( ppad, (char)fillchar, padlen );     // fill with fillchar
            if ( !(flags() & left) ) {
                writeBlock( ppad, padlen );
                padlen = 0;
            }
            writeBlock( s, len );
            if ( padlen )
                writeBlock( ppad, padlen );
            if ( ppad != padbuf )               // delete extra big fill buf
                delete[] ppad;
            return *this;
        }
    }
    writeBlock( s, len );
    return *this;
}

QTextStream & QTextStream::operator<<

(

const QString &

s

)

Writes s to the stream and returns a reference to the stream.

Definition at line 1867 of file qtextstream.cpp.

{
    CHECK_STREAM_PRECOND
    uint len = s.length();
    QString s1 = s;
    if ( fwidth ) {                             // field width set
        if ( !(flags() & left) ) {
            s1 = s.rightJustify(fwidth, (char)fillchar);
        } else {
            s1 = s.leftJustify(fwidth, (char)fillchar);
        }
        fwidth = 0;                             // reset width
    }
    writeBlock( s1.unicode(), len );
    return *this;
}

QTextStream & QTextStream::operator<<

(

const QCString &

s

)

Writes s to the stream and returns a reference to the stream.

The string s is assumed to be Latin1 encoded independent of the Encoding set for the QTextStream.

Definition at line 1858 of file qtextstream.cpp.

{
    return operator<<(s.data());
}

QTextStream & QTextStream::operator<<

(

void *

ptr

)

Writes a pointer to the stream and returns a reference to the stream.

The ptr is output as an unsigned long hexadecimal integer.

Definition at line 1891 of file qtextstream.cpp.

{
    int f = flags();
    setf( hex, basefield );
    setf( showbase );
    unsetf( uppercase );
    output_int( I_LONG | I_UNSIGNED, (uintptr_t)ptr, FALSE );
    flags( f );
    return *this;
}

QTextStream& QTextStream::operator= ( const QTextStream &  )

private

QTextStream & QTextStream::operator>>

(

QChar &

c

)

Reads a char from the stream and returns a reference to the stream. Note that whitespace is not skipped.

Definition at line 1041 of file qtextstream.cpp.

{
    CHECK_STREAM_PRECOND
    c = ts_getc();
    return *this;
}

QTextStream & QTextStream::operator>>

(

char &

c

)

Reads a char from the stream and returns a reference to the stream. Note that whitespace is skipped.

Definition at line 1029 of file qtextstream.cpp.

{
    CHECK_STREAM_PRECOND
    c = eat_ws();
    return *this;
}

QTextStream & QTextStream::operator>>

(

signed short &

i

)

Reads a signed short integer from the stream and returns a reference to the stream. See flags() for an explanation of expected input format.

Definition at line 1280 of file qtextstream.cpp.

{
    CHECK_STREAM_PRECOND
    i = (signed short)input_int();
    return *this;
}

QTextStream & QTextStream::operator>>

(

unsigned short &

i

)

Reads an unsigned short integer from the stream and returns a reference to the stream. See flags() for an explanation of expected input format.

Definition at line 1293 of file qtextstream.cpp.

{
    CHECK_STREAM_PRECOND
    i = (unsigned short)input_int();
    return *this;
}

QTextStream & QTextStream::operator>>

(

signed int &

i

)

Reads a signed int from the stream and returns a reference to the stream. See flags() for an explanation of expected input format.

Definition at line 1306 of file qtextstream.cpp.

{
    CHECK_STREAM_PRECOND
    i = (signed int)input_int();
    return *this;
}

QTextStream & QTextStream::operator>>

(

unsigned int &

i

)

Reads an unsigned int from the stream and returns a reference to the stream. See flags() for an explanation of expected input format.

Definition at line 1319 of file qtextstream.cpp.

{
    CHECK_STREAM_PRECOND
    i = (unsigned int)input_int();
    return *this;
}

QTextStream & QTextStream::operator>>

(

signed long &

i

)

Reads a signed long int from the stream and returns a reference to the stream. See flags() for an explanation of expected input format.

Definition at line 1332 of file qtextstream.cpp.

{
    CHECK_STREAM_PRECOND
    i = (signed long)input_int();
    return *this;
}

QTextStream & QTextStream::operator>>

(

unsigned long &

i

)

Reads an unsigned long int from the stream and returns a reference to the stream. See flags() for an explanation of expected input format.

Definition at line 1345 of file qtextstream.cpp.

{
    CHECK_STREAM_PRECOND
    i = (unsigned long)input_int();
    return *this;
}

QTextStream & QTextStream::operator>>

(

float &

f

)

Reads a float from the stream and returns a reference to the stream. See flags() for an explanation of expected input format.

Definition at line 1358 of file qtextstream.cpp.

{
    CHECK_STREAM_PRECOND
    f = (float)input_double();
    return *this;
}

QTextStream & QTextStream::operator>>

(

double &

f

)

Reads a double from the stream and returns a reference to the stream. See flags() for an explanation of expected input format.

Definition at line 1371 of file qtextstream.cpp.

{
    CHECK_STREAM_PRECOND
    f = input_double();
    return *this;
}

QTextStream & QTextStream::operator>>

(

char *

s

)

Reads a word from the stream and returns a reference to the stream.

Definition at line 1383 of file qtextstream.cpp.

{
    CHECK_STREAM_PRECOND
    int maxlen = width( 0 );
    QChar c = eat_ws();
    if ( !maxlen )
        maxlen = -1;
    while ( c != QEOF ) {
        if ( ts_isspace(c) || maxlen-- == 0 ) {
            ts_ungetc( c );
            break;
        }
        *s++ = c;
        c = ts_getc();
    }

    *s = '\0';
    return *this;
}

QTextStream & QTextStream::operator>>

(

QString &

str

)

Reads a word from the stream and returns a reference to the stream.

Definition at line 1407 of file qtextstream.cpp.

{
    CHECK_STREAM_PRECOND
    str=QString::fromLatin1("");
    QChar       c = eat_ws();

    while ( c != QEOF ) {
        if ( ts_isspace(c) ) {
            ts_ungetc( c );
            break;
        }
        str += c;
        c = ts_getc();
    }
    return *this;
}

QTextStream & QTextStream::operator>>

(

QCString &

str

)

Reads a word from the stream and returns a reference to the stream.

Definition at line 1428 of file qtextstream.cpp.

{
    CHECK_STREAM_PRECOND
    QCString  *dynbuf = 0;
    const int buflen = 256;
    char      buffer[buflen];
    char     *s = buffer;
    int       i = 0;
    QChar             c = eat_ws();

    while ( c != QEOF ) {
        if ( ts_isspace(c) ) {
            ts_ungetc( c );
            break;
        }
        if ( i >= buflen-1 ) {
            if ( !dynbuf )  {                   // create dynamic buffer
                dynbuf = new QCString(buflen*2);
                memcpy( dynbuf->rawData(), s, i );      // copy old data
            } else if ( i >= (int)dynbuf->size()-1 ) {
                dynbuf->resize( dynbuf->size()*2 );
            }
            s = dynbuf->rawData();
        }
        s[i++] = c;
        c = ts_getc();
    }
    str.resize( i+1 );
    memcpy( str.rawData(), s, i );
    delete dynbuf;
    return *this;
}

QTextStream & QTextStream::output_int ( int  format, ulong  n, bool  neg  )

private

Definition at line 1593 of file qtextstream.cpp.

{
    static char hexdigits_lower[] = "0123456789abcdef";
    static char hexdigits_upper[] = "0123456789ABCDEF";
    CHECK_STREAM_PRECOND
    char buf[76];
    register char *p;
    int   len;
    char *hexdigits;

    switch ( flags() & I_BASE_MASK ) {

        case I_BASE_2:                          // output binary number
            switch ( format & I_TYPE_MASK ) {
                case I_SHORT: len=16; break;
                case I_INT:   len=sizeof(int)*8; break;
                case I_LONG:  len=32; break;
                default:      len = 0;
            }
            p = &buf[74];                       // go reverse order
            *p = '\0';
            while ( len-- ) {
                *--p = (char)(n&1) + '0';
                n >>= 1;
                if ( !n )
                    break;
            }
            if ( flags() & showbase ) {         // show base
                *--p = (flags() & uppercase) ? 'B' : 'b';
                *--p = '0';
            }
            break;

        case I_BASE_8:                          // output octal number
            p = &buf[74];
            *p = '\0';
            do {
                *--p = (char)(n&7) + '0';
                n >>= 3;
            } while ( n );
            if ( flags() & showbase )
                *--p = '0';
            break;

        case I_BASE_16:                         // output hexadecimal number
            p = &buf[74];
            *p = '\0';
            hexdigits = (flags() & uppercase) ?
                hexdigits_upper : hexdigits_lower;
            do {
                *--p = hexdigits[(int)n&0xf];
                n >>= 4;
            } while ( n );
            if ( flags() & showbase ) {
                *--p = (flags() & uppercase) ? 'X' : 'x';
                *--p = '0';
            }
            break;

        default:                                // decimal base is default
            p = &buf[74];
            *p = '\0';
            if ( neg )
                n = (ulong)(-(long)n);
            do {
                *--p = ((int)(n%10)) + '0';
                n /= 10;
            } while ( n );
            if ( neg )
                *--p = '-';
            else if ( flags() & showpos )
                *--p = '+';
            if ( (flags() & internal) && fwidth && !ts_isdigit(*p) ) {
                ts_putc( *p );                  // special case for internal
                ++p;                            //   padding
                fwidth--;
                return *this << (const char*)p;
            }
    }
    if ( fwidth ) {                             // adjustment required
        if ( !(flags() & left) ) {              // but NOT left adjustment
            len = qstrlen(p);
            int padlen = fwidth - len;
            if ( padlen <= 0 ) {                // no padding required
                writeBlock( p, len );
            } else if ( padlen < (int)(p-buf) ) { // speeds up padding
                memset( p-padlen, (char)fillchar, padlen );
                writeBlock( p-padlen, padlen+len );
            }
            else                                // standard padding
                *this << (const char*)p;
        }
        else
            *this << (const char*)p;
        fwidth = 0;                             // reset field width
    }
    else
        writeBlock( p, qstrlen(p) );
    return *this;
}

int QTextStream::precision ( ) const

inline

Returns the precision. The default value is 6.

Definition at line 259 of file qtextstream.h.

{ return fprec; }

int QTextStream::precision ( int  p )

inline

Sets the precision to p. Returns the previous precision setting.

Definition at line 262 of file qtextstream.h.

{ int oldp = fprec;  fprec = p;  return oldp;  }

QString QTextStream::read

(

)

Reads the entire stream and returns a string containing the text.

See also

QIODevice::readLine()

Definition at line 1516 of file qtextstream.cpp.

{
#if defined(CHECK_STATE)
    if ( !dev ) {
        qWarning( "QTextStream::read: No device" );
        return QString::null;
    }
#endif
    QString    result;
    const uint bufsize = 512;
    QChar      buf[bufsize];
    uint       i, num, start;
    bool       skipped_cr = FALSE;

    while ( 1 ) {
        num = ts_getbuf(buf,bufsize);
        // do a s/\r\n/\n
        start = 0;
        for ( i=0; i<num; i++ ) {
            if ( buf[i] == '\r' ) {
                // Only skip single cr's preceding lf's
                if ( skipped_cr ) {
                    result += buf[i];
                    start++;
                } else {
                    result += QString( &buf[start], i-start );
                    start = i+1;
                    skipped_cr = TRUE;
                }
            } else {
                if ( skipped_cr ) {
                    if ( buf[i] != '\n' ) {
                        // Should not have skipped it
                        result += '\r';
                    }
                    skipped_cr = FALSE;
                }
            }
        }
        if ( start < num )
            result += QString( &buf[start], i-start );
        if ( num != bufsize ) // if ( EOF )
            break;
    }
    return result;
}

QString QTextStream::readLine

(

)

Reads a line from the stream and returns a string containing the text.

The returned string does not contain any trailing newline or carriage return. Note that this is different from QIODevice::readLine(), which does not strip the newline at the end of the line.

On EOF you will get a QString that is null. On reading an empty line the returned QString is empty but not null.

See also

QIODevice::readLine()

Definition at line 1475 of file qtextstream.cpp.

{
#if defined(CHECK_STATE)
    if ( !dev ) {
        qWarning( "QTextStream::readLine: No device" );
        return QString::null;
    }
#endif
    QString result( "" );
    const int buf_size = 256;
    QChar c[buf_size];
    int pos = 0;

    c[pos] = ts_getc();
    if ( c[pos] == QEOF )
        return QString::null;

    while ( c[pos] != QEOF && c[pos] != '\n' ) {
        pos++;
        if ( pos >= buf_size ) {
            result += QString( c, pos );
            pos = 0;
        }
        c[pos] = ts_getc();
    }
    result += QString( c, pos );

    int len = (int)result.length();
    if ( len && result[len-1] == '\r' )
        result.truncate(len-1); // (if there are two \r, let one stay)

    return result;
}

QTextStream & QTextStream::readRawBytes	(	char *	s,
		uint	len
	)

Reads len bytes from the stream into e s and returns a reference to the stream.

The buffer s must be preallocated.

Note that no encoding is done by this function.

Warning

The behaviour of this function is undefined unless the stream's encoding is set to Unicode or Latin1.

See also

QIODevice::readBlock()

Definition at line 883 of file qtextstream.cpp.

{
    dev->readBlock( s, len );
    return *this;
}

void QTextStream::reset

(

)

Resets the text stream.

• All flags are set to 0.
• The field width is set to 0.
• The fill character is set to ' ' (space).
• The precision is set to 6.

See also

setf(), width(), fill(), precision()

Definition at line 958 of file qtextstream.cpp.

{
    fflags = 0;
    fwidth = 0;
    fillchar = ' ';
    fprec = 6;
}

void QTextStream::setCodec

(

QTextCodec *

codec

)

Sets the codec for this stream to codec. Will not try to autodetect Unicode.

Note that this function should be called before any data is read to/written from the stream.

See also

setEncoding()

Definition at line 2228 of file qtextstream.cpp.

{
    if ( d->sourceType == QTextStreamPrivate::String )
        return; // QString does not need any codec
    mapper = codec;
    doUnicodeHeader = FALSE;
}

void QTextStream::setDevice

(

QIODevice *

iod

)

Sets the IO device to iod.

See also

device(), unsetDevice()

Definition at line 978 of file qtextstream.cpp.

{
    if ( owndev ) {
        delete dev;
        owndev = FALSE;
    }
    dev = iod;
    d->sourceType = QTextStreamPrivate::IODevice;
}

void QTextStream::setEncoding

(

Encoding

e

)

Sets the encoding of this stream to e, where e is one of:

• Locale Using local file format (Latin1 if locale is not set), but autodetecting Unicode(utf16) on input.
• Unicode Using Unicode(utf16) for input and output. Output will be written in the order most efficient for the current platform (i.e. the order used internally in QString).
• UnicodeUTF8 Using Unicode(utf8) for input and output. If you use it for input it will autodetect utf16 and use it instead of utf8.
• Latin1 ISO-8859-1. Will not autodetect utf16.
• UnicodeNetworkOrder Using network order Unicode(utf16) for input and output. Useful when reading Unicode data that does not start with the byte order marker.
• UnicodeReverse Using reverse network order Unicode(utf16) for input and output. Useful when reading Unicode data that does not start with the byte order marker, or writing data that should be read by buggy Windows applications.
• RawUnicode Like Unicode, but does not write the byte order marker, nor does it autodetect the byte order. Only useful when writing to non-persistent storage used by a single process.

Locale and all Unicode encodings, except RawUnicode, will look at the first two bytes in a input stream to determine the byte order. The initial byte order marker will be stripped off before data is read.

Note that this function should be called before any data is read to/written from the stream.

See also

setCodec()

Definition at line 2155 of file qtextstream.cpp.

{
    if ( d->sourceType == QTextStreamPrivate::String )
        return; // QString does not need any encoding
    switch ( e ) {
    case Unicode:
        mapper = 0;
        latin1 = FALSE;
        doUnicodeHeader = TRUE;
        internalOrder = TRUE;
        break;
    case UnicodeUTF8:
#ifndef QT_NO_CODECS
        mapper = QTextCodec::codecForMib( 106 );
        latin1 = FALSE;
        doUnicodeHeader = TRUE;
        internalOrder = TRUE;
#else
        mapper = 0;
        latin1 = TRUE;
        doUnicodeHeader = TRUE;
#endif
        break;
    case UnicodeNetworkOrder:
        mapper = 0;
        latin1 = FALSE;
        doUnicodeHeader = TRUE;
        internalOrder = QChar::networkOrdered();
        break;
    case UnicodeReverse:
        mapper = 0;
        latin1 = FALSE;
        doUnicodeHeader = TRUE;
        internalOrder = !QChar::networkOrdered();   //reverse network ordered
        break;
    case RawUnicode:
        mapper = 0;
        latin1 = FALSE;
        doUnicodeHeader = FALSE;
        internalOrder = TRUE;
        break;
    case Locale:
        latin1 = TRUE;                          // fallback to Latin 1
#ifndef QT_NO_TEXTCODEC
        mapper = QTextCodec::codecForLocale();
#if defined(_OS_WIN32_)
        if ( GetACP() == 1252 )
            mapper = 0;                         // Optimized latin1 processing
#endif
        if ( mapper && mapper->mibEnum() == 4 )
#endif
            mapper = 0;                         // Optimized latin1 processing
        doUnicodeHeader = TRUE; // If it reads as Unicode, accept it
        break;
    case Latin1:
        mapper = 0;
        doUnicodeHeader = FALSE;
        latin1 = TRUE;
        break;
    }
}

int QTextStream::setf ( int  bits )

inline

Sets the stream flag bits bits. Returns the previous stream flags.

Equivalent to flags( flags() | bits ).

See also

setf(), unsetf()

Definition at line 238 of file qtextstream.h.

{ int oldf = fflags;  fflags |= bits;  return oldf; }

int QTextStream::setf ( int  bits, int  mask  )

inline

Sets the stream flag bits bits with a bit mask mask. Returns the previous stream flags.

Equivalent to flags( (flags() & ~mask) | (bits & mask) ).

See also

setf(), unsetf()

Definition at line 241 of file qtextstream.h.

{ int oldf = fflags;  fflags = (fflags & ~mask) | (bits & mask); return oldf; }

void QTextStream::skipWhiteSpace

(

)

Positions the read pointer at the first non-whitespace character.

Definition at line 600 of file qtextstream.cpp.

{
    ts_ungetc( eat_ws() );
}

uint QTextStream::ts_getbuf ( QChar *  buf, uint  len  )

private

Tries to read len characters from the stream and stores them in buf. Returns the number of characters really read. Attention: There will no QEOF appended if the read reaches the end of the file. EOF is reached when the return value does not equal len.

Definition at line 620 of file qtextstream.cpp.

{
    if( len<1 )
        return 0;

    uint rnum=0;   // the number of QChars really read

    if ( d && d->ungetcBuf.length() ) {
        while( rnum < len && rnum < d->ungetcBuf.length() ) {
            buf[rnum] = d->ungetcBuf.constref(rnum);
            rnum++;
        }
        d->ungetcBuf = d->ungetcBuf.mid( rnum );
        if ( rnum >= len )
            return rnum;
    }

    // we use dev->ungetch() for one of the bytes of the unicode
    // byte-order mark, but a local unget hack for the other byte:
    int ungetHack = EOF;

    if ( doUnicodeHeader ) {
        doUnicodeHeader = FALSE; //only at the top
        int c1 = dev->getch();
        if ( c1 == EOF )
            return rnum;
        int c2 = dev->getch();
        if ( c1 == 0xfe && c2 == 0xff ) {
            mapper = 0;
            latin1 = FALSE;
            internalOrder = QChar::networkOrdered();   //network order
        } else if ( c1 == 0xff && c2 == 0xfe ) {
            mapper = 0;
            latin1 = FALSE;
            internalOrder = !QChar::networkOrdered();   //reverse network order
        } else {
            if ( c2 != EOF ) {
                dev->ungetch( c2 );
                ungetHack = c1;
            } else {
                dev->ungetch( c1 );
                // note that a small possible bug might hide here
                // here, if only the first byte of a file has made it
                // so far, and that first byte is half of the
                // byte-order mark, then the utfness will not be
                // detected.  whether or not this is a bug depends on
                // taste.  I can't really decide.
            }
        }
    }

#ifndef QT_NO_TEXTCODEC
    if ( mapper ) {
        bool shortRead = FALSE;
        if ( !d->decoder )
            d->decoder = mapper->makeDecoder();
        while( rnum < len ) {
            QString s;
            bool readBlock = !( len == 1+rnum );
            while ( TRUE ) {
                // for efficiency: normally read a whole block
                if ( readBlock ) {
                    // guess buffersize; this may be wrong (too small or too
                    // big). But we can handle this (either iterate reading
                    // or use ungetcBuf).
                    // Note that this might cause problems for codecs where
                    // one byte can result in >1 Unicode Characters if bytes
                    // are written to the stream in the meantime (loss of
                    // synchronicity).
                    uint rlen = len - rnum;
                    char *cbuf = new char[ rlen ];
                    if ( ungetHack != EOF ) {
                        rlen = 1+dev->readBlock( cbuf+1, rlen-1 );
                        cbuf[0] = (char)ungetHack;
                        ungetHack = EOF;
                    } else {
                        rlen = dev->readBlock( cbuf, rlen );
                    }
                    s  += d->decoder->toUnicode( cbuf, rlen );
                    delete[] cbuf;
                    // use buffered reading only for the first time, because we
                    // have to get the stream synchronous again (this is easier
                    // with single character reading)
                    readBlock = FALSE;
                }
                // get stream (and codec) in sync
                int c;
                if ( ungetHack == EOF ) {
                    c = dev->getch();
                } else {
                    c = ungetHack;
                    ungetHack = EOF;
                }
                if ( c == EOF ) {
                    shortRead = TRUE;
                    break;
                }
                char b = c;
                uint lengthBefore = s.length();
                s  += d->decoder->toUnicode( &b, 1 );
                if ( s.length() > lengthBefore )
                    break; // it seems we are in sync now
            }
            uint i = 0;
            while( rnum < len && i < s.length() )
                buf[rnum++] = s.constref(i++);
            if ( s.length() > i )
                // could be = but append is clearer
                d->ungetcBuf.append( s.mid( i ) );
            if ( shortRead )
                return rnum;
        }
    } else
#endif
    if ( latin1 ) {
        if ( len == 1+rnum ) {
            // use this method for one character because it is more efficient
            // (arnt doubts whether it makes a difference, but lets it stand)
            int c = (ungetHack == EOF) ? dev->getch() : ungetHack;
            if ( c != EOF )
                buf[rnum++] = (char)c;
        } else {
            if ( ungetHack != EOF ) {
                buf[rnum++] = (char)ungetHack;
                ungetHack = EOF;
            }
            char *cbuf = new char[len - rnum];
            while ( !dev->atEnd() && rnum < len ) {
                uint rlen = len - rnum;
                rlen = dev->readBlock( cbuf, rlen );
                uint i = 0;
                while( i < rlen )
                    buf[rnum++] = cbuf[i++];
            }
            delete[] cbuf;
        }
    } else { // UCS-2 or UTF-16
        if ( len == 1+rnum ) {
            int c1 = (ungetHack == EOF) ? dev->getch() : ungetHack;
            if ( c1 == EOF )
                return rnum;
            int c2 = dev->getch();
            if ( c2 == EOF )
                return rnum;
            if ( isNetworkOrder() )
                buf[rnum++] = QChar( c2, c1 );
            else
                buf[rnum++] = QChar( c1, c2 );
        } else {
            char *cbuf = new char[ 2*( len - rnum ) ]; // for paranoids: overflow possible
            while ( !dev->atEnd() && rnum < len ) {
                uint rlen = 2 * ( len-rnum );
                if ( ungetHack != EOF ) {
                    rlen = 1+dev->readBlock( cbuf+1, rlen-1 );
                    cbuf[0] = (char)ungetHack;
                    ungetHack = EOF;
                } else {
                    rlen = dev->readBlock( cbuf, rlen );
                }
                // We can't use an odd number of bytes, so put it back. But
                // do it only if we are capable of reading more -- normally
                // there should not be an odd number, but the file might be
                // truncated or not in UTF-16...
                if ( (rlen & 1) == 1 )
                    if ( !dev->atEnd() )
                        dev->ungetch( cbuf[--rlen] );
                uint i = 0;
                if ( isNetworkOrder() ) {
                    while( i < rlen ) {
                        buf[rnum++] = QChar( cbuf[i+1], cbuf[i] );
                        i+=2;
                    }
                } else {
                    while( i < rlen ) {
                        buf[rnum++] = QChar( cbuf[i], cbuf[i+1] );
                        i+=2;
                    }
                }
            }
            delete[] cbuf;
        }
    }
    return rnum;
}

QChar QTextStream::ts_getc ( )

inlineprivate

Returns one character from the stream, or EOF.

Definition at line 268 of file qtextstream.h.

{ QChar r; return ( ts_getbuf( &r,1 ) == 1 ? r : QChar((ushort)0xffff) ); }

bool QTextStream::ts_isdigit ( QChar  c )

private

Definition at line 849 of file qtextstream.cpp.

{
    return c.isDigit();
}

bool QTextStream::ts_isspace ( QChar  c )

private

Definition at line 854 of file qtextstream.cpp.

{
    return c.isSpace();
}

void QTextStream::ts_putc ( int  ch )

private

Puts one character to the stream.

Definition at line 844 of file qtextstream.cpp.

{
    ts_putc(QChar((ushort)ch));
}

void QTextStream::ts_putc ( QChar  c )

private

Puts one character to the stream.

Definition at line 809 of file qtextstream.cpp.

{
#ifndef QT_NO_TEXTCODEC
    if ( mapper ) {
        int len = 1;
        QString s = c;
        QCString block = mapper->fromUnicode( s, len );
        dev->writeBlock( block, len );
    } else
#endif
    if ( latin1 ) {
        if( c.row() )
            dev->putch( '?' ); //######unknown character???
        else
            dev->putch( c.cell() );
    } else {
        if ( doUnicodeHeader ) {
            doUnicodeHeader = FALSE;
            ts_putc( QChar::byteOrderMark );
        }
        if ( internalOrder ) {
            dev->writeBlock( (char*)&c, sizeof(QChar) );
        } else if ( isNetworkOrder() ) {
            dev->putch(c.row());
            dev->putch(c.cell());
        } else {
            dev->putch(c.cell());
            dev->putch(c.row());
        }
    }
}

void QTextStream::ts_ungetc ( QChar  c )

private

Definition at line 859 of file qtextstream.cpp.

{
    if ( c.unicode() == 0xffff )
        return;

    d->ungetcBuf.prepend( c );
}

void QTextStream::unsetDevice

(

)

Unsets the IO device. Equivalent to setDevice( 0 ).

See also

device(), setDevice()

Definition at line 993 of file qtextstream.cpp.

{
    setDevice( 0 );
    d->sourceType = QTextStreamPrivate::NotSet;
}

int QTextStream::unsetf ( int  bits )

inline

Clears the stream flag bits bits. Returns the previous stream flags.

Equivalent to flags( flags() & ~mask ).

See also

setf()

Definition at line 244 of file qtextstream.h.

{ int oldf = fflags;  fflags &= ~bits;  return oldf; }

int QTextStream::width ( ) const

inline

Returns the field width. The default value is 0.

Definition at line 247 of file qtextstream.h.

{ return fwidth; }

int QTextStream::width ( int  w )

inline

Sets the field width to w. Returns the previous field width.

Definition at line 250 of file qtextstream.h.

{ int oldw = fwidth;  fwidth = w;  return oldw;  }

QTextStream & QTextStream::writeBlock ( const char *  p, uint  len  )

private

Definition at line 905 of file qtextstream.cpp.

{
    if ( doUnicodeHeader ) {
        doUnicodeHeader = FALSE;
        if ( !mapper && !latin1 )
            ts_putc( QChar::byteOrderMark );
    }
    //All QCStrings and const char* are defined to be in Latin1
    if ( !mapper && latin1 ) {
        dev->writeBlock( p, len );
    } else if ( !mapper && internalOrder ) {
        QChar *u = new QChar[len];
        for (uint i=0; i<len; i++)
            u[i] = p[i];
        dev->writeBlock( (char*)u, len*(int)sizeof(QChar) );
        delete [] u;
    } else {
        for (uint i=0; i<len; i++)
            ts_putc( (uchar)p[i] );
    }
    return *this;
}

QTextStream & QTextStream::writeBlock ( const QChar *  p, uint  len  )

private

Definition at line 928 of file qtextstream.cpp.

{
    if ( !mapper && !latin1 && internalOrder ) {
        if ( doUnicodeHeader ) {
            doUnicodeHeader = FALSE;
            ts_putc( QChar::byteOrderMark );
        }
        dev->writeBlock( (char*)p, (int)sizeof(QChar)*len );
    } else {
        for (uint i=0; i<len; i++)
            ts_putc( p[i] );
    }
    return *this;
}

QTextStream & QTextStream::writeRawBytes	(	const char *	s,
		uint	len
	)

Writes the len bytes from s to the stream and returns a reference to the stream.

Note that no encoding is done by this function.

See also

QIODevice::writeBlock()

Definition at line 898 of file qtextstream.cpp.

{
    dev->writeBlock( s, len );
    return *this;
}

Member Data Documentation

const int QTextStream::adjustfield

static

Initial value:

= ( QTextStream::left |
                                       QTextStream::right |
                                       QTextStream::internal )

Definition at line 135 of file qtextstream.h.

const int QTextStream::basefield = I_BASE_MASK

static

Definition at line 134 of file qtextstream.h.

QTextStreamPrivate* QTextStream::d

private

Definition at line 167 of file qtextstream.h.

QIODevice* QTextStream::dev

private

Definition at line 157 of file qtextstream.h.

bool QTextStream::doUnicodeHeader

private

Definition at line 171 of file qtextstream.h.

int QTextStream::fflags

private

Definition at line 160 of file qtextstream.h.

int QTextStream::fillchar

private

Definition at line 162 of file qtextstream.h.

const int QTextStream::floatfield

static

Initial value:

= ( QTextStream::scientific |
                                       QTextStream::fixed )

Definition at line 136 of file qtextstream.h.

int QTextStream::fprec

private

Definition at line 163 of file qtextstream.h.

bool QTextStream::fstrm

private

Definition at line 164 of file qtextstream.h.

int QTextStream::fwidth

private

Definition at line 161 of file qtextstream.h.

bool QTextStream::internalOrder

private

Definition at line 170 of file qtextstream.h.

bool QTextStream::latin1

private

Definition at line 169 of file qtextstream.h.

QTextCodec* QTextStream::mapper

private

Definition at line 166 of file qtextstream.h.

bool QTextStream::owndev

private

Definition at line 165 of file qtextstream.h.

void* QTextStream::reserved_ptr

private

Definition at line 172 of file qtextstream.h.

QChar QTextStream::ungetcBuf

private

Definition at line 168 of file qtextstream.h.

---

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

• doxygen-1.8.11/qtools/qtextstream.h
• doxygen-1.8.11/qtools/qtextstream.cpp