qtools/qdatastream.cpp

   1 /****************************************************************************
   2 **
   3 **
   4 ** Implementation of QDataStream class
   5 **
   6 ** Created : 930831
   7 **
   8 ** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
   9 **
  10 ** This file is part of the tools module of the Qt GUI Toolkit.
  11 **
  12 ** This file may be distributed under the terms of the Q Public License
  13 ** as defined by Trolltech AS of Norway and appearing in the file
  14 ** LICENSE.QPL included in the packaging of this file.
  15 **
  16 ** This file may be distributed and/or modified under the terms of the
  17 ** GNU General Public License version 2 as published by the Free Software
  18 ** Foundation and appearing in the file LICENSE.GPL included in the
  19 ** packaging of this file.
  20 **
  21 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
  22 ** licenses may use this file in accordance with the Qt Commercial License
  23 ** Agreement provided with the Software.
  24 **
  25 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
  26 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  27 **
  28 ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
  29 **   information about Qt Commercial License Agreements.
  30 ** See http://www.trolltech.com/qpl/ for QPL licensing information.
  31 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
  32 **
  33 ** Contact info@trolltech.com if any conditions of this licensing are
  34 ** not clear to you.
  35 **
  36 **********************************************************************/
  37
  38 #include "qdatastream.h"
  39
  40 #ifndef QT_NO_DATASTREAM
  41 #include "qbuffer.h"
  42 #include <stdio.h>
  43 #include <ctype.h>
  44 #include <stdlib.h>
  45
  46 // REVISED: warwick
  47 /*!
  48   \class QDataStream qdatastream.h
  49
  50   \brief The QDataStream class provides serialization of
  51   binary data to a QIODevice.
  52
  53   \ingroup io
  54
  55   A data stream is a binary stream of encoded information which is 100%
  56   independent of the host computer operation system, CPU or byte order.  A
  57   stream that is written by a PC under DOS/Windows can be read by a
  58   Sun SPARC running Solaris.
  59
  60   The QDataStream class implements serialization of primitive types, like
  61   \c char, \c short, \c int, \c char* etc.  Serialization of more complex
  62   data is accomplished by breaking up the data into primitive units.
  63
  64   The programmer can select which byte order to use when serializing data.
  65   The default setting is big endian (MSB first). Changing it to little
  66   endian breaks the portability (unless the reader also changes to little
  67   endian).  We recommend keeping this setting unless you have
  68   special requirements.
  69
  70   A data stream cooperates closely with a QIODevice. A QIODevice
  71   represents an input/output medium one can read data from and write data
  72   to.  The QFile class is an example of an IO device.
  73
  74   Example (write data to a stream):
  75   \code
  76     QFile f( "file.dta" );
  77     f.open( IO_WriteOnly );                     // open file for writing
  78     QDataStream s( &f );                        // serialize using f
  79     s << "the answer is";                       // serialize string
  80     s << (Q_INT32)42;                           // serialize integer
  81   \endcode
  82
  83   Example (read data from a stream):
  84   \code
  85     QFile f( "file.dta" );
  86     f.open( IO_ReadOnly );                      // open file for reading
  87     QDataStream s( &f );                        // serialize using f
  88     char   *str;
  89     Q_INT32 a;
  90     s >> str >> a;                              // "the answer is" and 42
  91     delete str;                                 // delete string
  92   \endcode
  93
  94   In the last example, if you read into a QString instead of a \c char*
  95   you do not have to delete it.
  96
  97   Normally, each item written to the stream is written in a fixed binary
  98   format.
  99   For example, a \c char* is written as a 32-bit integer equal to the
 100   length of the string including the NUL byte, followed by all the
 101   characters of the string including the NUL byte. Similarly when
 102   reading a string, 4 bytes are read to create the 32-bit length value,
 103   then that many characters for the string including the NUL. For a complete
 104   description of all Qt types supporting data streaming see \link
 105   datastreamformat.html Format of the QDataStream operators \endlink .
 106
 107   If you want a "parsing" input stream, see QTextStream. If you just want the
 108   data to be human-readable to aid in debugging, you can set the data
 109   stream into printable data mode with setPrintableData(). The data is
 110   then written slower, in a human readable bloated form that is sufficient
 111   for debugging.
 112
 113   If you are producing a new binary data format, such as a file format
 114   for documents created by your application, you could use a QDataStream
 115   to write the data in a portable format. Typically, you would write
 116   a brief header containing a magic string and a version number to give
 117   yourself room for future expansion. For example:
 118
 119   \code
 120     // Open the file.
 121     QFile f( "file.xxx" );
 122     f.open( IO_WriteOnly );
 123     QDataStream s( &f );
 124
 125     // Write a header with a "magic number" and a version
 126     s << 0xa0b0c0d0;
 127     s << 123;
 128
 129     // Write the data
 130     s << [lots of interesting data]
 131   \endcode
 132
 133   Then read it in with:
 134
 135   \code
 136     // Open the file.
 137     QFile f( "file.xxx" );
 138     f.open( IO_ReadOnly );
 139     QDataStream s( &f );
 140
 141     // Read and check the header
 142     Q_UINT32 magic;
 143     s >> magic;
 144     if ( magic != 0xa0b0c0d0 )
 145         return XXX_BAD_FILE_FORMAT;
 146
 147     // Read the version
 148     Q_INT32 version;
 149     s >> version;
 150     if ( version < 100 )
 151         return XXX_BAD_FILE_TOO_OLD;
 152     if ( version > 123 )
 153         return XXX_BAD_FILE_TOO_NEW;
 154     if ( version <= 110 )
 155         s.setVersion(1);
 156
 157     // Read the data
 158     s >> [lots of interesting data];
 159     if ( version > 120 )
 160         s >> [data new in XXX version 1.2];
 161     s >> [other interesting data];
 162   \endcode
 163
 164   \sa QTextStream QVariant
 165 */
 166
 167
 168 /*****************************************************************************
 169   QDataStream member functions
 170  *****************************************************************************/
 171
 172 #if defined(CHECK_STATE)
 173 #undef  CHECK_STREAM_PRECOND
 174 #define CHECK_STREAM_PRECOND  if ( !dev ) {                             \
 175                                 qWarning( "QDataStream: No device" );   \
 176                                 return *this; }
 177 #else
 178 #define CHECK_STREAM_PRECOND
 179 #endif
 180
 181 static int  systemWordSize = 0;
 182 static bool systemBigEndian;
 183
 184 static const int DefaultStreamVersion = 3;
 185 // 3 is default in Qt 2.1
 186 // 2 is the Qt 2.0.x format
 187 // 1 is the Qt 1.x format
 188
 189 /*!
 190   Constructs a data stream that has no IO device.
 191
 192   \sa setDevice()
 193 */
 194
 195 QDataStream::QDataStream()
 196 {
 197     if ( systemWordSize == 0 )                  // get system features
 198         qSysInfo( &systemWordSize, &systemBigEndian );
 199     dev       = 0;                              // no device set
 200     owndev    = FALSE;
 201     byteorder = BigEndian;                      // default byte order
 202     printable = FALSE;
 203     ver       = DefaultStreamVersion;
 204     noswap    = systemBigEndian;
 205 }
 206
 207 /*!
 208   Constructs a data stream that uses the IO device \a d.
 209
 210   \sa setDevice(), device()
 211 */
 212
 213 QDataStream::QDataStream( QIODevice *d )
 214 {
 215     if ( systemWordSize == 0 )                  // get system features
 216         qSysInfo( &systemWordSize, &systemBigEndian );
 217     dev       = d;                              // set device
 218     owndev    = FALSE;
 219     byteorder = BigEndian;                      // default byte order
 220     printable = FALSE;
 221     ver       = DefaultStreamVersion;
 222     noswap    = systemBigEndian;
 223 }
 224
 225 /*!
 226   Constructs a data stream that operates on a byte array through an
 227   internal QBuffer device.
 228
 229   Example:
 230   \code
 231     static char bindata[] = { 231, 1, 44, ... };
 232     QByteArray  a;
 233     a.setRawData( bindata, sizeof(bindata) );   // a points to bindata
 234     QDataStream s( a, IO_ReadOnly );            // open on a's data
 235     s >> [something];                           // read raw bindata
 236     a.resetRawData( bindata, sizeof(bindata) ); // finished
 237   \endcode
 238
 239   The QArray::setRawData() function is not for the inexperienced.
 240 */
 241
 242 QDataStream::QDataStream( QByteArray a, int mode )
 243 {
 244     if ( systemWordSize == 0 )                  // get system features
 245         qSysInfo( &systemWordSize, &systemBigEndian );
 246     dev       = new QBuffer( a );               // create device
 247     ((QBuffer *)dev)->open( mode );             // open device
 248     owndev    = TRUE;
 249     byteorder = BigEndian;                      // default byte order
 250     printable = FALSE;
 251     ver       = DefaultStreamVersion;
 252     noswap    = systemBigEndian;
 253 }
 254
 255 /*!
 256   Destructs the data stream.
 257
 258   The destructor will not affect the current IO device, unless it
 259   is an internal IO device processing a QByteArray passed in the constructor.
 260 */
 261
 262 QDataStream::~QDataStream()
 263 {
 264     if ( owndev )
 265         delete dev;
 266 }
 267
 268
 269 /*!
 270   \fn QIODevice *QDataStream::device() const
 271   Returns the IO device currently set.
 272   \sa setDevice(), unsetDevice()
 273 */
 274
 275 /*!
 276   void QDataStream::setDevice(QIODevice *d )
 277   Sets the IO device to \a d.
 278   \sa device(), unsetDevice()
 279 */
 280
 281 void QDataStream::setDevice(QIODevice *d )
 282 {
 283     if ( owndev ) {
 284         delete dev;
 285         owndev = FALSE;
 286     }
 287     dev = d;
 288 }
 289
 290 /*!
 291   Unsets the IO device.  This is the same as calling setDevice( 0 ).
 292   \sa device(), setDevice()
 293 */
 294
 295 void QDataStream::unsetDevice()
 296 {
 297     setDevice( 0 );
 298 }
 299
 300
 301 /*!
 302   \fn bool QDataStream::atEnd() const
 303   Returns TRUE if the IO device has reached the end position (end of
 304   stream or file) or if there is no IO device set.
 305
 306   Returns FALSE if the current position of the read/write head of the IO
 307   device is somewhere before the end position.
 308
 309   \sa QIODevice::atEnd()
 310 */
 311
 312 /*!\fn bool QDataStream::eof() const
 313
 314   \obsolete
 315
 316   Returns TRUE if the IO device has reached the end position (end of
 317   stream or file) or if there is no IO device set.
 318
 319   Returns FALSE if the current position of the read/write head of the IO
 320   device is somewhere before the end position.
 321
 322   \sa QIODevice::atEnd()
 323 */
 324
 325 /*!
 326   \fn int QDataStream::byteOrder() const
 327   Returns the current byte order setting - either \c BigEndian or
 328   \c LittleEndian.
 329
 330   \sa setByteOrder()
 331 */
 332
 333 /*!
 334   Sets the serialization byte order to \a bo.
 335
 336   The \a bo parameter can be \c QDataStream::BigEndian or
 337   \c QDataStream::LittleEndian.
 338
 339   The default setting is big endian.  We recommend leaving this setting unless
 340   you have special requirements.
 341
 342   \sa byteOrder()
 343 */
 344
 345 void QDataStream::setByteOrder( int bo )
 346 {
 347     byteorder = bo;
 348     if ( systemBigEndian )
 349         noswap = byteorder == BigEndian;
 350     else
 351         noswap = byteorder == LittleEndian;
 352 }
 353
 354
 355 /*!
 356   \fn bool QDataStream::isPrintableData() const
 357   Returns TRUE if the printable data flag has been set.
 358   \sa setPrintableData()
 359 */
 360
 361 /*!
 362   \fn void QDataStream::setPrintableData( bool enable )
 363   Sets or clears the printable data flag.
 364
 365   If this flag is set, the write functions will generate output that
 366   consists of printable characters (7 bit ASCII).
 367
 368   We recommend enabling printable data only for debugging purposes
 369   (it is slower and creates larger output).
 370 */
 371
 372
 373 /*!
 374   \fn int QDataStream::version() const
 375   Returns the version number of the data serialization format.
 376   In Qt 2.1, this number is by default 3.
 377   \sa setVersion()
 378 */
 379
 380 /*!
 381   \fn void QDataStream::setVersion( int v )
 382   Sets the version number of the data serialization format.
 383
 384   In order to accommodate for new functionality, the datastream
 385   serialization format of some Qt classes has changed in some versions of
 386   Qt. If you want to read data that was created by an earlier version of
 387   Qt, or write data that can be read by a program that was compiled with
 388   an earlier version of Qt, use this function to modify the serialization
 389   format of QDataStream.
 390
 391   For Qt 1.x compatibility, use \a v == 1.
 392
 393   For Qt 2.0.x compatibility, use \a v == 2 (Not required for reading in
 394   Qt 2.1).
 395
 396   \sa version()
 397 */
 398
 399 /*****************************************************************************
 400   QDataStream read functions
 401  *****************************************************************************/
 402
 403
 404 static Q_INT32 read_int_ascii( QDataStream *s )
 405 {
 406     register int n = 0;
 407     char buf[40];
 408     while ( TRUE ) {
 409         buf[n] = s->device()->getch();
 410         if ( buf[n] == '\n' || n > 38 )         // $-terminator
 411             break;
 412         n++;
 413     }
 414     buf[n] = '\0';
 415     return (Q_INT32)atol( buf );
 416 }
 417
 418
 419 /*!
 420   \fn QDataStream &QDataStream::operator>>( Q_UINT8 &i )
 421   Reads an unsigned byte from the stream and returns a reference to
 422   the stream.
 423 */
 424
 425 /*!
 426   Reads a signed byte from the stream.
 427 */
 428
 429 QDataStream &QDataStream::operator>>( Q_INT8 &i )
 430 {
 431     CHECK_STREAM_PRECOND
 432     if ( printable ) {                          // printable data
 433         i = (Q_INT8)dev->getch();
 434         if ( i == '\\' ) {                      // read octal code
 435             char buf[4];
 436             dev->readBlock( buf, 3 );
 437             i = (buf[2] & 0x07)+((buf[1] & 0x07) << 3)+((buf[0] & 0x07) << 6);
 438         }
 439     } else {                                    // data or text
 440         i = (Q_INT8)dev->getch();
 441     }
 442     return *this;
 443 }
 444
 445
 446 /*!
 447   \fn QDataStream &QDataStream::operator>>( Q_UINT16 &i )
 448   Reads an unsigned 16-bit integer from the stream and returns a reference to
 449   the stream.
 450 */
 451
 452 /*!
 453   Reads a signed 16-bit integer from the stream and returns a reference to
 454   the stream.
 455 */
 456
 457 QDataStream &QDataStream::operator>>( Q_INT16 &i )
 458 {
 459     CHECK_STREAM_PRECOND
 460     if ( printable ) {                          // printable data
 461         i = (Q_INT16)read_int_ascii( this );
 462     } else if ( noswap ) {                      // no conversion needed
 463         dev->readBlock( (char *)&i, sizeof(Q_INT16) );
 464     } else {                                    // swap bytes
 465         register uchar *p = (uchar *)(&i);
 466         char b[2];
 467         dev->readBlock( b, 2 );
 468         *p++ = b[1];
 469         *p   = b[0];
 470     }
 471     return *this;
 472 }
 473
 474
 475 /*!
 476   \fn QDataStream &QDataStream::operator>>( Q_UINT32 &i )
 477   Reads an unsigned 32-bit integer from the stream and returns a reference to
 478   the stream.
 479 */
 480
 481 /*!
 482   Reads a signed 32-bit integer from the stream and returns a reference to
 483   the stream.
 484 */
 485
 486 QDataStream &QDataStream::operator>>( Q_INT32 &i )
 487 {
 488     CHECK_STREAM_PRECOND
 489     if ( printable ) {                          // printable data
 490         i = read_int_ascii( this );
 491     } else if ( noswap ) {                      // no conversion needed
 492         dev->readBlock( (char *)&i, sizeof(Q_INT32) );
 493     } else {                                    // swap bytes
 494         register uchar *p = (uchar *)(&i);
 495         char b[4];
 496         dev->readBlock( b, 4 );
 497         *p++ = b[3];
 498         *p++ = b[2];
 499         *p++ = b[1];
 500         *p   = b[0];
 501     }
 502     return *this;
 503 }
 504
 505 /*!
 506   \fn QDataStream &QDataStream::operator>>( Q_UINT64 &i )
 507   Reads an unsigned 64-bit integer from the stream and returns a reference to
 508   the stream, or uses the Q_UINT32 operator if 64 bit is not available.
 509 */
 510
 511 /*!
 512   Reads a signed 64-bit integer from the stream and returns a reference to
 513   the stream, or uses the Q_UINT32 operator if 64 bit is not available.
 514 */
 515
 516 QDataStream &QDataStream::operator>>( Q_INT64 &i )
 517 {
 518     CHECK_STREAM_PRECOND
 519     if ( printable ) {                          // printable data
 520         i = read_int_ascii( this );
 521     } else if ( noswap ) {                      // no conversion needed
 522         dev->readBlock( (char *)&i, sizeof(Q_INT64) );
 523     } else {                                    // swap bytes
 524         register uchar *p = (uchar *)(&i);
 525         char b[sizeof(Q_INT64)];
 526         dev->readBlock( b, sizeof(Q_INT64) );
 527         if ( sizeof(Q_INT64) == 8 ) {
 528             *p++ = b[7];
 529             *p++ = b[6];
 530             *p++ = b[5];
 531             *p++ = b[4];
 532         }
 533         *p++ = b[3];
 534         *p++ = b[2];
 535         *p++ = b[1];
 536         *p   = b[0];
 537     }
 538     return *this;
 539 }
 540
 541 static double read_double_ascii( QDataStream *s )
 542 {
 543     register int n = 0;
 544     char buf[80];
 545     while ( TRUE ) {
 546         buf[n] = s->device()->getch();
 547         if ( buf[n] == '\n' || n > 78 )         // $-terminator
 548             break;
 549         n++;
 550     }
 551     buf[n] = '\0';
 552     return atof( buf );
 553 }
 554
 555
 556 /*!
 557   Reads a 32-bit floating point number from the stream using the standard
 558   IEEE754 format. Returns a reference to the stream.
 559 */
 560
 561 QDataStream &QDataStream::operator>>( float &f )
 562 {
 563     CHECK_STREAM_PRECOND
 564     if ( printable ) {                          // printable data
 565         f = (float)read_double_ascii( this );
 566     } else if ( noswap ) {                      // no conversion needed
 567         dev->readBlock( (char *)&f, sizeof(float) );
 568     } else {                                    // swap bytes
 569         register uchar *p = (uchar *)(&f);
 570         char b[4];
 571         dev->readBlock( b, 4 );
 572         *p++ = b[3];
 573         *p++ = b[2];
 574         *p++ = b[1];
 575         *p   = b[0];
 576     }
 577     return *this;
 578 }
 579
 580
 581 /*!
 582   Reads a 64-bit floating point number from the stream using the standard
 583   IEEE754 format. Returns a reference to the stream.
 584 */
 585
 586 QDataStream &QDataStream::operator>>( double &f )
 587 {
 588     CHECK_STREAM_PRECOND
 589     if ( printable ) {                          // printable data
 590         f = read_double_ascii( this );
 591     } else if ( noswap ) {                      // no conversion needed
 592         dev->readBlock( (char *)&f, sizeof(double) );
 593     } else {                                    // swap bytes
 594         register uchar *p = (uchar *)(&f);
 595         char b[8];
 596         dev->readBlock( b, 8 );
 597         *p++ = b[7];
 598         *p++ = b[6];
 599         *p++ = b[5];
 600         *p++ = b[4];
 601         *p++ = b[3];
 602         *p++ = b[2];
 603         *p++ = b[1];
 604         *p   = b[0];
 605     }
 606     return *this;
 607 }
 608
 609
 610 /*!
 611   Reads the '\0'-terminated string \a s from the stream and returns
 612   a reference to the stream.
 613
 614   Space for the string is allocated using \c new - the caller must
 615   eventually call delete[] on the value.
 616 */
 617
 618 QDataStream &QDataStream::operator>>( char *&s )
 619 {
 620     uint len = 0;
 621     return readBytes( s, len );
 622 }
 623
 624
 625 /*!
 626   Reads the buffer \a s from the stream and returns a reference to the
 627   stream.
 628
 629   The buffer \a s is allocated using \c new. Destroy it with the \c delete[]
 630   operator.  If the length is zero or \a s cannot be allocated, \a s is
 631   set to 0.
 632
 633   The \a l parameter will be set to the length of the buffer.
 634
 635   The serialization format is an Q_UINT32 length specifier first, then the
 636   data (\a l bytes).
 637
 638   \sa readRawBytes(), writeBytes()
 639 */
 640
 641 QDataStream &QDataStream::readBytes( char *&s, uint &l )
 642 {
 643     CHECK_STREAM_PRECOND
 644     Q_UINT32 len;
 645     *this >> len;                               // first read length spec
 646     l = (uint)len;
 647     if ( len == 0 || eof() ) {
 648         s = 0;
 649         return *this;
 650     } else {
 651         s = new char[len];                      // create char array
 652         CHECK_PTR( s );
 653         if ( !s )                               // no memory
 654             return *this;
 655         return readRawBytes( s, (uint)len );
 656     }
 657 }
 658
 659
 660 /*!
 661   Reads \a len bytes from the stream into \a s and returns a reference to
 662   the stream.
 663
 664   The buffer \a s must be preallocated.
 665
 666   \sa readBytes(), QIODevice::readBlock(), writeRawBytes()
 667 */
 668
 669 QDataStream &QDataStream::readRawBytes( char *s, uint len )
 670 {
 671     CHECK_STREAM_PRECOND
 672     if ( printable ) {                          // printable data
 673         register Q_INT8 *p = (Q_INT8*)s;
 674         while ( len-- )
 675             *this >> *p++;
 676     } else {                                    // read data char array
 677         dev->readBlock( s, len );
 678     }
 679     return *this;
 680 }
 681
 682
 683 /*****************************************************************************
 684   QDataStream write functions
 685  *****************************************************************************/
 686
 687
 688 /*!
 689   \fn QDataStream &QDataStream::operator<<( Q_UINT8 i )
 690   Writes an unsigned byte to the stream and returns a reference to
 691   the stream.
 692 */
 693
 694 /*!
 695   Writes a signed byte to the stream.
 696 */
 697
 698 QDataStream &QDataStream::operator<<( Q_INT8 i )
 699 {
 700     CHECK_STREAM_PRECOND
 701     if ( printable && (i == '\\' || !isprint(i)) ) {
 702         char buf[6];                            // write octal code
 703         buf[0] = '\\';
 704         buf[1] = '0' + ((i >> 6) & 0x07);
 705         buf[2] = '0' + ((i >> 3) & 0x07);
 706         buf[3] = '0' + (i & 0x07);
 707         buf[4] = '\0';
 708         dev->writeBlock( buf, 4 );
 709     } else {
 710         dev->putch( i );
 711     }
 712     return *this;
 713 }
 714
 715
 716 /*!
 717   \fn QDataStream &QDataStream::operator<<( Q_UINT16 i )
 718   Writes an unsigned 16-bit integer to the stream and returns a reference
 719   to the stream.
 720 */
 721
 722 /*!
 723   Writes a signed 16-bit integer to the stream and returns a reference to
 724   the stream.
 725 */
 726
 727 QDataStream &QDataStream::operator<<( Q_INT16 i )
 728 {
 729     CHECK_STREAM_PRECOND
 730     if ( printable ) {                          // printable data
 731         char buf[16];
 732         sprintf( buf, "%d\n", i );
 733         dev->writeBlock( buf, strlen(buf) );
 734     } else if ( noswap ) {                      // no conversion needed
 735         dev->writeBlock( (char *)&i, sizeof(Q_INT16) );
 736     } else {                                    // swap bytes
 737         register uchar *p = (uchar *)(&i);
 738         char b[2];
 739         b[1] = *p++;
 740         b[0] = *p;
 741         dev->writeBlock( b, 2 );
 742     }
 743     return *this;
 744 }
 745
 746
 747 /*!
 748   \fn QDataStream &QDataStream::operator<<( Q_UINT32 i )
 749   Writes an unsigned 32-bit integer to the stream and returns a reference to
 750   the stream.
 751 */
 752
 753 /*!
 754   Writes a signed 32-bit integer to the stream and returns a reference to
 755   the stream.
 756 */
 757
 758 QDataStream &QDataStream::operator<<( Q_INT32 i )
 759 {
 760     CHECK_STREAM_PRECOND
 761     if ( printable ) {                          // printable data
 762         char buf[16];
 763         sprintf( buf, "%d\n", i );
 764         dev->writeBlock( buf, strlen(buf) );
 765     } else if ( noswap ) {                      // no conversion needed
 766         dev->writeBlock( (char *)&i, sizeof(Q_INT32) );
 767     } else {                                    // swap bytes
 768         register uchar *p = (uchar *)(&i);
 769         char b[4];
 770         b[3] = *p++;
 771         b[2] = *p++;
 772         b[1] = *p++;
 773         b[0] = *p;
 774         dev->writeBlock( b, 4 );
 775     }
 776     return *this;
 777 }
 778
 779 /*!
 780   \fn QDataStream &QDataStream::operator<<( Q_UINT64 i )
 781   Writes an unsigned 64-bit integer to the stream and returns a reference to
 782   the stream, or uses the Q_UINT32-operator if 64 bit is not available.
 783 */
 784
 785 /*!
 786   Writes a signed 64-bit integer to the stream and returns a reference to
 787   the stream, or calls the Q_INT32-operator if 64 bit is not available.
 788 */
 789
 790 QDataStream &QDataStream::operator<<( Q_INT64 i )
 791 {
 792     CHECK_STREAM_PRECOND
 793     if ( printable ) {                          // printable data
 794         char buf[20];
 795         sprintf( buf, "%ld\n", i );
 796         dev->writeBlock( buf, strlen(buf) );
 797     } else if ( noswap ) {                      // no conversion needed
 798         dev->writeBlock( (char *)&i, sizeof(Q_INT64) );
 799     } else {                                    // swap bytes
 800         register uchar *p = (uchar *)(&i);
 801         char b[sizeof(Q_INT64)];
 802         if ( sizeof(Q_INT64) == 8 ) {
 803             b[7] = *p++;
 804             b[6] = *p++;
 805             b[5] = *p++;
 806             b[4] = *p++;
 807         }
 808         b[3] = *p++;
 809         b[2] = *p++;
 810         b[1] = *p++;
 811         b[0] = *p;
 812         dev->writeBlock( b, sizeof(Q_INT64) );
 813     }
 814     return *this;
 815 }
 816
 817 /*!
 818   \fn QDataStream &QDataStream::operator<<( uint i )
 819   Writes an unsigned integer to the stream as a 32-bit unsigned integer
 820   (Q_UINT32).
 821   Returns a reference to the stream.
 822 */
 823
 824 /*!
 825   \fn QDataStream &QDataStream::operator<<( int i )
 826   Writes a signed integer to the stream as a 32-bit signed integer (Q_INT32).
 827   Returns a reference to the stream.
 828 */
 829
 830
 831 /*!
 832   Writes a 32-bit floating point number to the stream using the standard
 833   IEEE754 format.  Returns a reference to the stream.
 834 */
 835
 836 QDataStream &QDataStream::operator<<( float f )
 837 {
 838     CHECK_STREAM_PRECOND
 839     if ( printable ) {                          // printable data
 840         char buf[32];
 841         sprintf( buf, "%g\n", (double)f );
 842         dev->writeBlock( buf, strlen(buf) );
 843     } else {
 844         float g = f;                            // fixes float-on-stack problem
 845         if ( noswap ) {                         // no conversion needed
 846             dev->writeBlock( (char *)&g, sizeof(float) );
 847         } else {                                // swap bytes
 848             register uchar *p = (uchar *)(&g);
 849             char b[4];
 850             b[3] = *p++;
 851             b[2] = *p++;
 852             b[1] = *p++;
 853             b[0] = *p;
 854             dev->writeBlock( b, 4 );
 855         }
 856     }
 857     return *this;
 858 }
 859
 860
 861 /*!
 862   Writes a 64-bit floating point number to the stream using the standard
 863   IEEE754 format.  Returns a reference to the stream.
 864 */
 865
 866 QDataStream &QDataStream::operator<<( double f )
 867 {
 868     CHECK_STREAM_PRECOND
 869     if ( printable ) {                          // printable data
 870         char buf[32];
 871         sprintf( buf, "%g\n", f );
 872         dev->writeBlock( buf, strlen(buf) );
 873     } else if ( noswap ) {                      // no conversion needed
 874         dev->writeBlock( (char *)&f, sizeof(double) );
 875     } else {                                    // swap bytes
 876         register uchar *p = (uchar *)(&f);
 877         char b[8];
 878         b[7] = *p++;
 879         b[6] = *p++;
 880         b[5] = *p++;
 881         b[4] = *p++;
 882         b[3] = *p++;
 883         b[2] = *p++;
 884         b[1] = *p++;
 885         b[0] = *p;
 886         dev->writeBlock( b, 8 );
 887     }
 888     return *this;
 889 }
 890
 891
 892 /*!
 893   Writes the '\0'-terminated string \a s to the stream and returns
 894   a reference to the stream.
 895
 896   The string is serialized using writeBytes().
 897 */
 898
 899 QDataStream &QDataStream::operator<<( const char *s )
 900 {
 901     if ( !s ) {
 902         *this << (Q_UINT32)0;
 903         return *this;
 904     }
 905     uint len = qstrlen( s ) + 1;                        // also write null terminator
 906     *this << (Q_UINT32)len;                     // write length specifier
 907     return writeRawBytes( s, len );
 908 }
 909
 910
 911 /*!
 912   Writes the length specifier \a len and the buffer \a s to the stream and
 913   returns a reference to the stream.
 914
 915   The \a len is serialized as an Q_UINT32, followed by \a len bytes from
 916   \a s.
 917
 918   \sa writeRawBytes(), readBytes()
 919 */
 920
 921 QDataStream &QDataStream::writeBytes(const char *s, uint len)
 922 {
 923     CHECK_STREAM_PRECOND
 924     *this << (Q_UINT32)len;                     // write length specifier
 925     if ( len )
 926         writeRawBytes( s, len );
 927     return *this;
 928 }
 929
 930
 931 /*!
 932   Writes \a len bytes from \a s to the stream and returns a reference to the
 933   stream.
 934
 935   \sa writeBytes(), QIODevice::writeBlock(), readRawBytes()
 936 */
 937
 938 QDataStream &QDataStream::writeRawBytes( const char *s, uint len )
 939 {
 940     CHECK_STREAM_PRECOND
 941     if ( printable ) {                          // write printable
 942         register char *p = (char *)s;
 943         while ( len-- )
 944             *this << *p++;
 945     } else {                                    // write data char array
 946         dev->writeBlock( s, len );
 947     }
 948     return *this;
 949 }
 950
 951 #endif // QT_NO_DATASTREAM