qdatastream.cpp

Go to the documentation of this file.

/****************************************************************************
** $Id: qdatastream.cpp,v 1.2 2003/07/10 02:40:11 llornkcor Exp $
**
** Implementation of QDataStream class
**
** Created : 930831
**
** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
**
** This file is part of the tools module of the Qt GUI Toolkit.
**
** This file may be distributed under the terms of the Q Public License
** as defined by Trolltech AS of Norway and appearing in the file
** LICENSE.QPL included in the packaging of this file.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
** licenses may use this file in accordance with the Qt Commercial License
** Agreement provided with the Software.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
**   information about Qt Commercial License Agreements.
** See http://www.trolltech.com/qpl/ for QPL licensing information.
** See http://www.trolltech.com/gpl/ for GPL licensing information.
**
** Contact info@trolltech.com if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/

#include "qdatastream.h"

#ifndef QT_NO_DATASTREAM
#include "qbuffer.h"
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>

/*****************************************************************************
  QDataStream member functions
 *****************************************************************************/

#if defined(QT_CHECK_STATE)
#undef  CHECK_STREAM_PRECOND
#define CHECK_STREAM_PRECOND  if ( !dev ) {                             \
                                qWarning( "QDataStream: No device" );   \
                                return *this; }
#else
#define CHECK_STREAM_PRECOND
#endif

static int  systemWordSize = 0;
static bool systemBigEndian;

static const int DefaultStreamVersion = 5;
// 5 is default in Qt 3.1
// 4 is default in Qt 3.0
// 3 is default in Qt 2.1
// 2 is the Qt 2.0.x format
// 1 is the Qt 1.x format

QDataStream::QDataStream()
{
    if ( systemWordSize == 0 )                  // get system features
        qSysInfo( &systemWordSize, &systemBigEndian );
    dev       = 0;                              // no device set
    owndev    = FALSE;
    byteorder = BigEndian;                      // default byte order
    printable = FALSE;
    ver       = DefaultStreamVersion;
    noswap    = systemBigEndian;
}

QDataStream::QDataStream( QIODevice *d )
{
    if ( systemWordSize == 0 )                  // get system features
        qSysInfo( &systemWordSize, &systemBigEndian );
    dev       = d;                              // set device
    owndev    = FALSE;
    byteorder = BigEndian;                      // default byte order
    printable = FALSE;
    ver       = DefaultStreamVersion;
    noswap    = systemBigEndian;
}

QDataStream::QDataStream( QByteArray a, int mode )
{
    if ( systemWordSize == 0 )                  // get system features
        qSysInfo( &systemWordSize, &systemBigEndian );
    dev       = new QBuffer( a );               // create device
    ((QBuffer *)dev)->open( mode );             // open device
    owndev    = TRUE;
    byteorder = BigEndian;                      // default byte order
    printable = FALSE;
    ver       = DefaultStreamVersion;
    noswap    = systemBigEndian;
}

QDataStream::~QDataStream()
{
    if ( owndev )
        delete dev;
}


void QDataStream::setDevice(QIODevice *d )
{
    if ( owndev ) {
        delete dev;
        owndev = FALSE;
    }
    dev = d;
}

void QDataStream::unsetDevice()
{
    setDevice( 0 );
}


void QDataStream::setByteOrder( int bo )
{
    byteorder = bo;
    if ( systemBigEndian )
        noswap = byteorder == BigEndian;
    else
        noswap = byteorder == LittleEndian;
}


/*****************************************************************************
  QDataStream read functions
 *****************************************************************************/


static Q_INT32 read_int_ascii( QDataStream *s )
{
    register int n = 0;
    char buf[40];
    for ( ;; ) {
        buf[n] = s->device()->getch();
        if ( buf[n] == '\n' || n > 38 )         // $-terminator
            break;
        n++;
    }
    buf[n] = '\0';
    return atol( buf );
}


QDataStream &QDataStream::operator>>( Q_INT8 &i )
{
    CHECK_STREAM_PRECOND
    if ( printable ) {                          // printable data
        i = (Q_INT8)dev->getch();
        if ( i == '\\' ) {                      // read octal code
            char buf[4];
            dev->readBlock( buf, 3 );
            i = (buf[2] & 0x07)+((buf[1] & 0x07) << 3)+((buf[0] & 0x07) << 6);
        }
    } else {                                    // data or text
        i = (Q_INT8)dev->getch();
    }
    return *this;
}


QDataStream &QDataStream::operator>>( Q_INT16 &i )
{
    CHECK_STREAM_PRECOND
    if ( printable ) {                          // printable data
        i = (Q_INT16)read_int_ascii( this );
    } else if ( noswap ) {                      // no conversion needed
        dev->readBlock( (char *)&i, sizeof(Q_INT16) );
    } else {                                    // swap bytes
        register uchar *p = (uchar *)(&i);
        char b[2];
        dev->readBlock( b, 2 );
        *p++ = b[1];
        *p   = b[0];
    }
    return *this;
}


QDataStream &QDataStream::operator>>( Q_INT32 &i )
{
    CHECK_STREAM_PRECOND
    if ( printable ) {                          // printable data
        i = read_int_ascii( this );
    } else if ( noswap ) {                      // no conversion needed
        dev->readBlock( (char *)&i, sizeof(Q_INT32) );
    } else {                                    // swap bytes
        uchar *p = (uchar *)(&i);
        char b[4];
        dev->readBlock( b, 4 );
        *p++ = b[3];
        *p++ = b[2];
        *p++ = b[1];
        *p   = b[0];
    }
    return *this;
}

QDataStream &QDataStream::operator>>( Q_LONG &i )
{
    CHECK_STREAM_PRECOND
    if ( printable ) {                          // printable data
        i = read_int_ascii( this );
    } else if ( noswap ) {                      // no conversion needed
        dev->readBlock( (char *)&i, sizeof(Q_LONG) );
    } else {                                    // swap bytes
        register uchar *p = (uchar *)(&i);
        char b[sizeof(Q_LONG)];
        dev->readBlock( b, sizeof(Q_LONG) );
        for ( int j = sizeof(Q_LONG); j;  )
            *p++ = b[--j];
    }
    return *this;
}

static double read_double_ascii( QDataStream *s )
{
    register int n = 0;
    char buf[80];
    for ( ;; ) {
        buf[n] = s->device()->getch();
        if ( buf[n] == '\n' || n > 78 )         // $-terminator
            break;
        n++;
    }
    buf[n] = '\0';
    return atof( buf );
}


QDataStream &QDataStream::operator>>( float &f )
{
    CHECK_STREAM_PRECOND
    if ( printable ) {                          // printable data
        f = (float)read_double_ascii( this );
    } else if ( noswap ) {                      // no conversion needed
        dev->readBlock( (char *)&f, sizeof(float) );
    } else {                                    // swap bytes
        uchar *p = (uchar *)(&f);
        char b[4];
        dev->readBlock( b, 4 );
        *p++ = b[3];
        *p++ = b[2];
        *p++ = b[1];
        *p   = b[0];
    }
    return *this;
}


QDataStream &QDataStream::operator>>( double &f )
{
    CHECK_STREAM_PRECOND
    if ( printable ) {                          // printable data
        f = read_double_ascii( this );
    } else if ( noswap ) {                      // no conversion needed
        dev->readBlock( (char *)&f, sizeof(double) );
    } else {                                    // swap bytes
        register uchar *p = (uchar *)(&f);
        char b[8];
        dev->readBlock( b, 8 );
        *p++ = b[7];
        *p++ = b[6];
        *p++ = b[5];
        *p++ = b[4];
        *p++ = b[3];
        *p++ = b[2];
        *p++ = b[1];
        *p   = b[0];
    }
    return *this;
}


QDataStream &QDataStream::operator>>( char *&s )
{
    uint len = 0;
    return readBytes( s, len );
}


QDataStream &QDataStream::readBytes( char *&s, uint &l )
{
    CHECK_STREAM_PRECOND
    Q_UINT32 len;
    *this >> len;                               // first read length spec
    l = (uint)len;
    if ( len == 0 || eof() ) {
        s = 0;
        return *this;
    } else {
        s = new char[len];                      // create char array
        Q_CHECK_PTR( s );
        if ( !s )                               // no memory
            return *this;
        return readRawBytes( s, (uint)len );
    }
}


QDataStream &QDataStream::readRawBytes( char *s, uint len )
{
    CHECK_STREAM_PRECOND
    if ( printable ) {                          // printable data
        register Q_INT8 *p = (Q_INT8*)s;
        if ( version() < 4 ) {
            while ( len-- ) {
                Q_INT32 tmp;
                *this >> tmp;
                *p++ = tmp;
            }
        } else {
            while ( len-- )
                *this >> *p++;
        }
    } else {                                    // read data char array
        dev->readBlock( s, len );
    }
    return *this;
}


/*****************************************************************************
  QDataStream write functions
 *****************************************************************************/


QDataStream &QDataStream::operator<<( Q_INT8 i )
{
    CHECK_STREAM_PRECOND
    if ( printable && (i == '\\' || !isprint((uchar) i)) ) {
        char buf[6];                            // write octal code
        buf[0] = '\\';
        buf[1] = '0' + ((i >> 6) & 0x07);
        buf[2] = '0' + ((i >> 3) & 0x07);
        buf[3] = '0' + (i & 0x07);
        buf[4] = '\0';
        dev->writeBlock( buf, 4 );
    } else {
        dev->putch( i );
    }
    return *this;
}


QDataStream &QDataStream::operator<<( Q_INT16 i )
{
    CHECK_STREAM_PRECOND
    if ( printable ) {                          // printable data
        char buf[16];
        sprintf( buf, "%d\n", i );
        dev->writeBlock( buf, strlen(buf) );
    } else if ( noswap ) {                      // no conversion needed
        dev->writeBlock( (char *)&i, sizeof(Q_INT16) );
    } else {                                    // swap bytes
        register uchar *p = (uchar *)(&i);
        char b[2];
        b[1] = *p++;
        b[0] = *p;
        dev->writeBlock( b, 2 );
    }
    return *this;
}

QDataStream &QDataStream::operator<<( Q_INT32 i )
{
    CHECK_STREAM_PRECOND
    if ( printable ) {                          // printable data
        char buf[16];
        sprintf( buf, "%d\n", i );
        dev->writeBlock( buf, strlen(buf) );
    } else if ( noswap ) {                      // no conversion needed
        dev->writeBlock( (char *)&i, sizeof(Q_INT32) );
    } else {                                    // swap bytes
        register uchar *p = (uchar *)(&i);
        char b[4];
        b[3] = *p++;
        b[2] = *p++;
        b[1] = *p++;
        b[0] = *p;
        dev->writeBlock( b, 4 );
    }
    return *this;
}

QDataStream &QDataStream::operator<<( Q_LONG i )
{
    CHECK_STREAM_PRECOND
    if ( printable ) {                          // printable data
        char buf[20];
        sprintf( buf, "%ld\n", i );
        dev->writeBlock( buf, strlen(buf) );
    } else if ( noswap ) {                      // no conversion needed
        dev->writeBlock( (char *)&i, sizeof(Q_LONG) );
    } else {                                    // swap bytes
        register uchar *p = (uchar *)(&i);
        char b[sizeof(Q_LONG)];
        for ( int j = sizeof(Q_LONG); j;  )
            b[--j] = *p++;
        dev->writeBlock( b, sizeof(Q_LONG) );
    }
    return *this;
}

QDataStream &QDataStream::operator<<( float f )
{
    CHECK_STREAM_PRECOND
    if ( printable ) {                          // printable data
        char buf[32];
        sprintf( buf, "%g\n", (double)f );
        dev->writeBlock( buf, strlen(buf) );
    } else {
        float g = f;                            // fixes float-on-stack problem
        if ( noswap ) {                         // no conversion needed
            dev->writeBlock( (char *)&g, sizeof(float) );
        } else {                                // swap bytes
            register uchar *p = (uchar *)(&g);
            char b[4];
            b[3] = *p++;
            b[2] = *p++;
            b[1] = *p++;
            b[0] = *p;
            dev->writeBlock( b, 4 );
        }
    }
    return *this;
}


QDataStream &QDataStream::operator<<( double f )
{
    CHECK_STREAM_PRECOND
    if ( printable ) {                          // printable data
        char buf[32];
        sprintf( buf, "%g\n", f );
        dev->writeBlock( buf, strlen(buf) );
    } else if ( noswap ) {                      // no conversion needed
        dev->writeBlock( (char *)&f, sizeof(double) );
    } else {                                    // swap bytes
        register uchar *p = (uchar *)(&f);
        char b[8];
        b[7] = *p++;
        b[6] = *p++;
        b[5] = *p++;
        b[4] = *p++;
        b[3] = *p++;
        b[2] = *p++;
        b[1] = *p++;
        b[0] = *p;
        dev->writeBlock( b, 8 );
    }
    return *this;
}


QDataStream &QDataStream::operator<<( const char *s )
{
    if ( !s ) {
        *this << (Q_UINT32)0;
        return *this;
    }
    uint len = qstrlen( s ) + 1;                        // also write null terminator
    *this << (Q_UINT32)len;                     // write length specifier
    return writeRawBytes( s, len );
}


QDataStream &QDataStream::writeBytes(const char *s, uint len)
{
    CHECK_STREAM_PRECOND
    *this << (Q_UINT32)len;                     // write length specifier
    if ( len )
        writeRawBytes( s, len );
    return *this;
}


QDataStream &QDataStream::writeRawBytes( const char *s, uint len )
{
    CHECK_STREAM_PRECOND
    if ( printable ) {                          // write printable
        if ( version() < 4 ) {
            register char *p = (char *)s;
            while ( len-- )
                *this << *p++;
        } else {
            register Q_INT8 *p = (Q_INT8*)s;
            while ( len-- )
                *this << *p++;
        }
    } else {                                    // write data char array
        dev->writeBlock( s, len );
    }
    return *this;
}

#endif // QT_NO_DATASTREAM

---