diff options
Diffstat (limited to 'tqtinterface/qt4/src/tools/tqdatastream.cpp')
| -rw-r--r-- | tqtinterface/qt4/src/tools/tqdatastream.cpp | 1176 |
1 files changed, 0 insertions, 1176 deletions
diff --git a/tqtinterface/qt4/src/tools/tqdatastream.cpp b/tqtinterface/qt4/src/tools/tqdatastream.cpp deleted file mode 100644 index bf9955a..0000000 --- a/tqtinterface/qt4/src/tools/tqdatastream.cpp +++ /dev/null @@ -1,1176 +0,0 @@ -/**************************************************************************** -** -** Implementation of TQDataStream class -** -** Created : 930831 -** -** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA. -** -** This file is part of the tools module of the TQt GUI Toolkit. -** -** This file may be used under the terms of the GNU General -** Public License versions 2.0 or 3.0 as published by the Free -** Software Foundation and appearing in the files LICENSE.GPL2 -** and LICENSE.GPL3 included in the packaging of this file. -** Alternatively you may (at your option) use any later version -** of the GNU General Public License if such license has been -** publicly approved by Trolltech ASA (or its successors, if any) -** and the KDE Free TQt Foundation. -** -** Please review the following information to ensure GNU General -** Public Licensing requirements will be met: -** http://trolltech.com/products/qt/licenses/licensing/opensource/. -** If you are unsure which license is appropriate for your use, please -** review the following information: -** http://trolltech.com/products/qt/licenses/licensing/licensingoverview -** or contact the sales department at sales@trolltech.com. -** -** This file may be used under the terms of the Q Public License as -** defined by Trolltech ASA and appearing in the file LICENSE.TQPL -** included in the packaging of this file. Licensees holding valid TQt -** Commercial licenses may use this file in accordance with the TQt -** Commercial License Agreement provided with the Software. -** -** This file is provided "AS IS" with NO WARRANTY OF ANY KIND, -** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR -** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted -** herein. -** -**********************************************************************/ - -#include "tqdatastream.h" - -#ifndef TQT_NO_DATASTREAM -#include "tqbuffer.h" -#include <stdio.h> -#include <ctype.h> -#include <stdlib.h> -#ifndef TQ_OS_TEMP -#include <locale.h> -#else -#include "tqt_windows.h" -#endif - -#ifdef USE_QT4 - -#else // USE_QT4 - -/*! - \class TQDataStream tqdatastream.h - \reentrant - \brief The TQDataStream class provides serialization of binary data - to a TQIODevice. - - \ingroup io - - A data stream is a binary stream of encoded information which is - 100% independent of the host computer's operating system, CPU or - byte order. For example, a data stream that is written by a PC - under Windows can be read by a Sun SPARC running Solaris. - - You can also use a data stream to read/write \link #raw raw - unencoded binary data\endlink. If you want a "parsing" input - stream, see TQTextStream. - - The TQDataStream class implements the serialization of C++'s basic - data types, like \c char, \c short, \c int, \c char*, etc. - Serialization of more complex data is accomplished by breaking up - the data into primitive units. - - A data stream cooperates closely with a TQIODevice. A TQIODevice - represents an input/output medium one can read data from and write - data to. The TQFile class is an example of an IO tqdevice. - - Example (write binary data to a stream): - \code - TQFile file( "file.dat" ); - file.open( IO_WriteOnly ); - TQDataStream stream( &file ); // we will serialize the data into the file - stream << "the answer is"; // serialize a string - stream << (TQ_INT32)42; // serialize an integer - \endcode - - Example (read binary data from a stream): - \code - TQFile file( "file.dat" ); - file.open( IO_ReadOnly ); - TQDataStream stream( &file ); // read the data serialized from the file - TQString str; - TQ_INT32 a; - stream >> str >> a; // extract "the answer is" and 42 - \endcode - - Each item written to the stream is written in a predefined binary - format that varies depending on the item's type. Supported TQt - types include TQBrush, TQColor, TQDateTime, TQFont, TQPixmap, TQString, - TQVariant and many others. For the complete list of all TQt types - supporting data streaming see the \link datastreamformat.html - Format of the TQDataStream operators \endlink. - - For integers it is best to always cast to a TQt integer type for - writing, and to read back into the same TQt integer type. This - ensures that you get integers of the size you want and insulates - you from compiler and platform differences. - - To take one example, a \c char* string is written as a 32-bit - integer equal to the length of the string including the NUL byte - ('\0'), followed by all the characters of the string including the - NUL byte. When reading a \c char* string, 4 bytes are read to - create the 32-bit length value, then that many characters for the - \c char* string including the NUL are read. - - The initial IODevice is usually set in the constructor, but can be - changed with setDevice(). If you've reached the end of the data - (or if there is no IODevice set) atEnd() will return TRUE. - - If you want the data to be compatible with an earlier version of - TQt use setVersion(). - - If you want the data to be human-readable, e.g. for debugging, you - can set the data stream into printable data mode with - setPrintableData(). The data is then written slower, in a bloated - but human readable format. - - If you are producing a new binary data format, such as a file - format for documents created by your application, you could use a - TQDataStream to write the data in a portable format. Typically, you - would write a brief header containing a magic string and a version - number to give yourself room for future expansion. For example: - - \code - TQFile file( "file.xxx" ); - file.open( IO_WriteOnly ); - TQDataStream stream( &file ); - - // Write a header with a "magic number" and a version - stream << (TQ_UINT32)0xA0B0C0D0; - stream << (TQ_INT32)123; - - // Write the data - stream << [lots of interesting data] - \endcode - - Then read it in with: - - \code - TQFile file( "file.xxx" ); - file.open( IO_ReadOnly ); - TQDataStream stream( &file ); - - // Read and check the header - TQ_UINT32 magic; - stream >> magic; - if ( magic != 0xA0B0C0D0 ) - return XXX_BAD_FILE_FORMAT; - - // Read the version - TQ_INT32 version; - stream >> version; - if ( version < 100 ) - return XXX_BAD_FILE_TOO_OLD; - if ( version > 123 ) - return XXX_BAD_FILE_TOO_NEW; - if ( version <= 110 ) - stream.setVersion(1); - - // Read the data - stream >> [lots of interesting data]; - if ( version > 120 ) - stream >> [data new in XXX version 1.2]; - stream >> [other interesting data]; - \endcode - - You can select which byte order to use when serializing data. The - default setting is big endian (MSB first). Changing it to little - endian breaks the portability (unless the reader also changes to - little endian). We recommend keeping this setting unless you have - special requirements. - - \target raw - \section1 Reading and writing raw binary data - - You may wish to read/write your own raw binary data to/from the - data stream directly. Data may be read from the stream into a - preallocated char* using readRawBytes(). Similarly data can be - written to the stream using writeRawBytes(). Notice that any - encoding/decoding of the data must be done by you. - - A similar pair of functions is readBytes() and writeBytes(). These - differ from their \e raw counterparts as follows: readBytes() - reads a TQ_UINT32 which is taken to be the length of the data to be - read, then that number of bytes is read into the preallocated - char*; writeBytes() writes a TQ_UINT32 containing the length of the - data, followed by the data. Notice that any encoding/decoding of - the data (apart from the length TQ_UINT32) must be done by you. - - \sa TQTextStream TQVariant -*/ - -/*! - \enum TQDataStream::ByteOrder - - The byte order used for reading/writing the data. - - \value BigEndian the default - \value LittleEndian -*/ - - -/***************************************************************************** - TQDataStream member functions - *****************************************************************************/ - -#if defined(TQT_CHECK_STATE) -#undef CHECK_STREAM_PRECOND -#define CHECK_STREAM_PRECOND if ( !dev ) { \ - qWarning( "TQDataStream: No tqdevice" ); \ - return *this; } -#else -#define CHECK_STREAM_PRECOND -#endif - -static int systemWordSize = 0; -static bool systemBigEndian; - -static const int DefaultStreamVersion = 6; -// ### On next version bump, TQPen::width() should not be restricted to 8-bit values. -// ### On next version bump, when streaming invalid TQVariants, just the type should -// be written, no "data" after it -// 6 is default in TQt 3.3 -// 5 is default in TQt 3.1 -// 4 is default in TQt 3.0 -// 3 is default in TQt 2.1 -// 2 is the TQt 2.0.x format -// 1 is the TQt 1.x format - -/*! - Constructs a data stream that has no IO tqdevice. - - \sa setDevice() -*/ - -TQDataStream::TQDataStream() -{ - if ( systemWordSize == 0 ) // get system features - qSysInfo( &systemWordSize, &systemBigEndian ); - dev = 0; // no tqdevice set - owndev = FALSE; - byteorder = BigEndian; // default byte order - printable = FALSE; - ver = DefaultStreamVersion; - noswap = systemBigEndian; -} - -/*! - Constructs a data stream that uses the IO tqdevice \a d. - - \warning If you use TQSocket or TQSocketDevice as the IO tqdevice \a d - for reading data, you must make sure that enough data is available - on the socket for the operation to successfully proceed; - TQDataStream does not have any means to handle or recover from - short-reads. - - \sa setDevice(), tqdevice() -*/ - -TQDataStream::TQDataStream( TQIODevice *d ) -{ - if ( systemWordSize == 0 ) // get system features - qSysInfo( &systemWordSize, &systemBigEndian ); - dev = d; // set tqdevice - owndev = FALSE; - byteorder = BigEndian; // default byte order - printable = FALSE; - ver = DefaultStreamVersion; - noswap = systemBigEndian; -} - -/*! - Constructs a data stream that operates on a byte array, \a a, - through an internal TQBuffer tqdevice. The \a mode is a - TQIODevice::mode(), usually either \c IO_ReadOnly or \c - IO_WriteOnly. - - Example: - \code - static char bindata[] = { 231, 1, 44, ... }; - TQByteArray a; - a.setRawData( bindata, sizeof(bindata) ); // a points to bindata - TQDataStream stream( a, IO_ReadOnly ); // open on a's data - stream >> [something]; // read raw bindata - a.resetRawData( bindata, sizeof(bindata) ); // finished - \endcode - - The TQByteArray::setRawData() function is not for the inexperienced. -*/ - -TQDataStream::TQDataStream( TQByteArray a, int mode ) -{ - if ( systemWordSize == 0 ) // get system features - qSysInfo( &systemWordSize, &systemBigEndian ); - dev = new TQBuffer( a ); // create tqdevice - ((TQBuffer *)dev)->open( mode ); // open tqdevice - owndev = TRUE; - byteorder = BigEndian; // default byte order - printable = FALSE; - ver = DefaultStreamVersion; - noswap = systemBigEndian; -} - -/*! - Destroys the data stream. - - The destructor will not affect the current IO tqdevice, unless it is - an internal IO tqdevice processing a TQByteArray passed in the \e - constructor, in which case the internal IO tqdevice is destroyed. -*/ - -TQDataStream::~TQDataStream() -{ - if ( owndev ) - delete dev; -} - - -/*! - \fn TQIODevice *TQDataStream::tqdevice() const - - Returns the IO tqdevice currently set. - - \sa setDevice(), unsetDevice() -*/ - -/*! - void TQDataStream::setDevice(TQIODevice *d ) - - Sets the IO tqdevice to \a d. - - \sa tqdevice(), unsetDevice() -*/ - -void TQDataStream::setDevice(TQIODevice *d ) -{ - if ( owndev ) { - delete dev; - owndev = FALSE; - } - dev = d; -} - -/*! - Unsets the IO tqdevice. This is the same as calling setDevice( 0 ). - - \sa tqdevice(), setDevice() -*/ - -void TQDataStream::unsetDevice() -{ - setDevice( 0 ); -} - - -/*! - \fn bool TQDataStream::atEnd() const - - Returns TRUE if the IO tqdevice has reached the end position (end of - the stream or file) or if there is no IO tqdevice set; otherwise - returns FALSE, i.e. if the current position of the IO tqdevice is - before the end position. - - \sa TQIODevice::atEnd() -*/ - -/*!\fn bool TQDataStream::eof() const - - \obsolete - - Returns TRUE if the IO tqdevice has reached the end position (end of - stream or file) or if there is no IO tqdevice set. - - Returns FALSE if the current position of the read/write head of the IO - tqdevice is somewhere before the end position. - - \sa TQIODevice::atEnd() -*/ - -/*! - \fn int TQDataStream::byteOrder() const - - Returns the current byte order setting -- either \c BigEndian or - \c LittleEndian. - - \sa setByteOrder() -*/ - -/*! - Sets the serialization byte order to \a bo. - - The \a bo parameter can be \c TQDataStream::BigEndian or \c - TQDataStream::LittleEndian. - - The default setting is big endian. We recommend leaving this - setting unless you have special requirements. - - \sa byteOrder() -*/ - -void TQDataStream::setByteOrder( int bo ) -{ - byteorder = bo; - if ( systemBigEndian ) - noswap = byteorder == BigEndian; - else - noswap = byteorder == LittleEndian; -} - - -/*! - \fn bool TQDataStream::isPrintableData() const - - Returns TRUE if the printable data flag has been set; otherwise - returns FALSE. - - \sa setPrintableData() -*/ - -/*! - \fn void TQDataStream::setPrintableData( bool enable ) - - If \a enable is TRUE, data will be output in a human readable - format. If \a enable is FALSE, data will be output in a binary - format. - - If \a enable is TRUE, the write functions will generate output - that consists of printable characters (7 bit ASCII). This output - will typically be a lot larger than the default binary output, and - consequently slower to write. - - We recommend only enabling printable data for debugging purposes. -*/ - - -/*! - \fn int TQDataStream::version() const - - Returns the version number of the data serialization format. In TQt - 3.1, this number is 5. - - \sa setVersion() -*/ - -/*! - \fn void TQDataStream::setVersion( int v ) - - Sets the version number of the data serialization format to \a v. - - You don't need to set a version if you are using the current - version of TQt. - - In order to accommodate new functionality, the datastream - serialization format of some TQt classes has changed in some - versions of TQt. If you want to read data that was created by an - earlier version of TQt, or write data that can be read by a program - that was compiled with an earlier version of TQt, use this function - to modify the serialization format of TQDataStream. - - \table - \header \i TQt Version \i TQDataStream Version - \row \i TQt 3.3 \i11 6 - \row \i TQt 3.2 \i11 5 - \row \i TQt 3.1 \i11 5 - \row \i TQt 3.0 \i11 4 - \row \i TQt 2.1.x and TQt 2.2.x \i11 3 - \row \i TQt 2.0.x \i11 2 - \row \i TQt 1.x \i11 1 - \endtable - - \sa version() -*/ - -/***************************************************************************** - TQDataStream read functions - *****************************************************************************/ - -#if defined(TQ_OS_HPUX) && !defined(__LP64__) -extern "C" long long __strtoll( const char *, char**, int ); -#endif - -static TQ_INT64 read_int_ascii( TQDataStream *s ) -{ - register int n = 0; - char buf[40]; - for ( ;; ) { - buf[n] = s->tqdevice()->getch(); - if ( buf[n] == '\n' || n > 38 ) // $-terminator - break; - n++; - } - buf[n] = '\0'; - -#if defined(__LP64__) || defined(TQ_OS_OSF) - // sizeof(long) == 8 - return strtol(buf, (char **)0, 10); -#else -# if defined(TQ_OS_TEMP) - return strtol( buf, (char**)0, 10 ); -# elif defined(TQ_OS_WIN) - return _atoi64( buf ); -# elif defined(TQ_OS_HPUX) - return __strtoll( buf, (char**)0, 10 ); -# elif defined(TQ_OS_MACX) && defined(TQT_MACOSX_VERSION) && TQT_MACOSX_VERSION < 0x1020 - return strtoq( buf, (char**)0, 10 ); -# else - return strtoll( buf, (char**)0, 10 ); // C99 function -# endif -#endif -} - -/*! - \overload TQDataStream &TQDataStream::operator>>( TQ_UINT8 &i ) - - Reads an unsigned byte from the stream into \a i, and returns a - reference to the stream. -*/ - -/*! - Reads a signed byte from the stream into \a i, and returns a - reference to the stream. -*/ - -TQDataStream &TQDataStream::operator>>( TQ_INT8 &i ) -{ - CHECK_STREAM_PRECOND - if ( printable ) { // printable data - i = (TQ_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 = (TQ_INT8)dev->getch(); - } - return *this; -} - - -/*! - \overload TQDataStream &TQDataStream::operator>>( TQ_UINT16 &i ) - - Reads an unsigned 16-bit integer from the stream into \a i, and - returns a reference to the stream. -*/ - -/*! - \overload - - Reads a signed 16-bit integer from the stream into \a i, and - returns a reference to the stream. -*/ - -TQDataStream &TQDataStream::operator>>( TQ_INT16 &i ) -{ - CHECK_STREAM_PRECOND - if ( printable ) { // printable data - i = (TQ_INT16)read_int_ascii( this ); - } else if ( noswap ) { // no conversion needed - dev->readBlock( (char *)&i, sizeof(TQ_INT16) ); - } else { // swap bytes - register uchar *p = (uchar *)(&i); - char b[2]; - dev->readBlock( b, 2 ); - *p++ = b[1]; - *p = b[0]; - } - return *this; -} - - -/*! - \overload TQDataStream &TQDataStream::operator>>( TQ_UINT32 &i ) - - Reads an unsigned 32-bit integer from the stream into \a i, and - returns a reference to the stream. -*/ - -/*! - \overload - - Reads a signed 32-bit integer from the stream into \a i, and - returns a reference to the stream. -*/ - -TQDataStream &TQDataStream::operator>>( TQ_INT32 &i ) -{ - CHECK_STREAM_PRECOND - if ( printable ) { // printable data - i = (TQ_INT32)read_int_ascii( this ); - } else if ( noswap ) { // no conversion needed - dev->readBlock( (char *)&i, sizeof(TQ_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; -} - -/*! - \overload TQDataStream &TQDataStream::operator>>( TQ_UINT64 &i ) - - Reads an unsigned 64-bit integer from the stream, into \a i, and - returns a reference to the stream. -*/ - -/*! - \overload - - Reads a signed 64-bit integer from the stream into \a i, and - returns a reference to the stream. -*/ - -TQDataStream &TQDataStream::operator>>( TQ_INT64 &i ) -{ - CHECK_STREAM_PRECOND - if ( printable ) { // printable data - i = read_int_ascii( this ); - } else if ( version() < 6 ) { - TQ_UINT32 i1, i2; - *this >> i2 >> i1; - i = ((TQ_UINT64)i1 << 32) + i2; - } else if ( noswap ) { // no conversion needed - dev->readBlock( (char *)&i, sizeof(TQ_INT64) ); - } else { // swap bytes - uchar *p = (uchar *)(&i); - 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; -} - - -/*! - \overload TQDataStream &TQDataStream::operator>>( TQ_ULONG &i ) - - Reads an unsigned integer of the system's word length from the - stream, into \a i, and returns a reference to the stream. -*/ - -#if !defined(TQ_OS_WIN64) -/*! - \overload - - Reads a signed integer of the system's word length from the stream - into \a i, and returns a reference to the stream. - -*/ - -TQDataStream &TQDataStream::operator>>( TQ_LONG &i ) -{ - CHECK_STREAM_PRECOND - if ( printable ) { // printable data - i = (TQ_LONG)read_int_ascii( this ); - } else if ( noswap ) { // no conversion needed - dev->readBlock( (char *)&i, sizeof(TQ_LONG) ); - } else { // swap bytes - register uchar *p = (uchar *)(&i); - char b[sizeof(TQ_LONG)]; - dev->readBlock( b, sizeof(TQ_LONG) ); - for ( int j = sizeof(TQ_LONG); j; ) - *p++ = b[--j]; - } - return *this; -} -#endif - -static double read_double_ascii( TQDataStream *s ) -{ - register int n = 0; - char buf[80]; - for ( ;; ) { - buf[n] = s->tqdevice()->getch(); - if ( buf[n] == '\n' || n > 78 ) // $-terminator - break; - n++; - } - buf[n] = '\0'; - return atof( buf ); -} - - -/*! - \overload - - Reads a 32-bit floating point number from the stream into \a f, - using the standard IEEE754 format. Returns a reference to the - stream. -*/ - -TQDataStream &TQDataStream::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; -} - - -/*! - \overload - - Reads a 64-bit floating point number from the stream into \a f, - using the standard IEEE754 format. Returns a reference to the - stream. -*/ - -TQDataStream &TQDataStream::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; -} - - -/*! - \overload - - Reads the '\0'-terminated string \a s from the stream and returns - a reference to the stream. - - Space for the string is allocated using \c new -- the caller must - destroy it with delete[]. -*/ - -TQDataStream &TQDataStream::operator>>( char *&s ) -{ - uint len = 0; - return readBytes( s, len ); -} - - -/*! - Reads the buffer \a s from the stream and returns a reference to - the stream. - - The buffer \a s is allocated using \c new. Destroy it with the \c - delete[] operator. If the length is zero or \a s cannot be - allocated, \a s is set to 0. - - The \a l parameter will be set to the length of the buffer. - - The serialization format is a TQ_UINT32 length specifier first, - then \a l bytes of data. Note that the data is \e not encoded. - - \sa readRawBytes(), writeBytes() -*/ - -TQDataStream &TQDataStream::readBytes( char *&s, uint &l ) -{ - CHECK_STREAM_PRECOND - TQ_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 - TQ_CHECK_PTR( s ); - if ( !s ) // no memory - return *this; - return readRawBytes( s, (uint)len ); - } -} - - -/*! - Reads \a len bytes from the stream into \a s and returns a - reference to the stream. - - The buffer \a s must be preallocated. The data is \e not encoded. - - \sa readBytes(), TQIODevice::readBlock(), writeRawBytes() -*/ - -TQDataStream &TQDataStream::readRawBytes( char *s, uint len ) -{ - CHECK_STREAM_PRECOND - if ( printable ) { // printable data - register TQ_INT8 *p = (TQ_INT8*)s; - if ( version() < 4 ) { - while ( len-- ) { - TQ_INT32 tmp; - *this >> tmp; - *p++ = tmp; - } - } else { - while ( len-- ) - *this >> *p++; - } - } else { // read data char array - dev->readBlock( s, len ); - } - return *this; -} - - -/***************************************************************************** - TQDataStream write functions - *****************************************************************************/ - - -/*! - \overload TQDataStream &TQDataStream::operator<<( TQ_UINT8 i ) - - Writes an unsigned byte, \a i, to the stream and returns a - reference to the stream. -*/ - -/*! - Writes a signed byte, \a i, to the stream and returns a reference - to the stream. -*/ - -TQDataStream &TQDataStream::operator<<( TQ_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; -} - - -/*! - \overload TQDataStream &TQDataStream::operator<<( TQ_UINT16 i ) - - Writes an unsigned 16-bit integer, \a i, to the stream and returns - a reference to the stream. -*/ - -/*! - \overload - - Writes a signed 16-bit integer, \a i, to the stream and returns a - reference to the stream. -*/ - -TQDataStream &TQDataStream::operator<<( TQ_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(TQ_INT16) ); - } else { // swap bytes - register uchar *p = (uchar *)(&i); - char b[2]; - b[1] = *p++; - b[0] = *p; - dev->writeBlock( b, 2 ); - } - return *this; -} - -/*! - \overload - - Writes a signed 32-bit integer, \a i, to the stream and returns a - reference to the stream. -*/ - -TQDataStream &TQDataStream::operator<<( TQ_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(TQ_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; -} - -/*! - \overload TQDataStream &TQDataStream::operator<<( TQ_UINT64 i ) - - Writes an unsigned 64-bit integer, \a i, to the stream and returns a - reference to the stream. -*/ - -/*! - \overload - - Writes a signed 64-bit integer, \a i, to the stream and returns a - reference to the stream. -*/ - -TQDataStream &TQDataStream::operator<<( TQ_INT64 i ) -{ - CHECK_STREAM_PRECOND - if ( printable ) { // printable data - char buf[16]; -#ifdef TQ_OS_WIN - sprintf( buf, "%I64d\n", i ); -#else - sprintf( buf, "%lld\n", i ); -#endif - dev->writeBlock( buf, strlen(buf) ); - } else if ( version() < 6 ) { - TQ_UINT32 i1 = i & 0xffffffff; - TQ_UINT32 i2 = i >> 32; - *this << i2 << i1; - } else if ( noswap ) { // no conversion needed - dev->writeBlock( (char *)&i, sizeof(TQ_INT64) ); - } else { // swap bytes - register uchar *p = (uchar *)(&i); - 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; -} - -/*! - \overload TQDataStream &TQDataStream::operator<<( TQ_ULONG i ) - - Writes an unsigned integer \a i, of the system's word length, to - the stream and returns a reference to the stream. -*/ - -#if !defined(TQ_OS_WIN64) -/*! - \overload - - Writes a signed integer \a i, of the system's word length, to the - stream and returns a reference to the stream. -*/ - -TQDataStream &TQDataStream::operator<<( TQ_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(TQ_LONG) ); - } else { // swap bytes - register uchar *p = (uchar *)(&i); - char b[sizeof(TQ_LONG)]; - for ( int j = sizeof(TQ_LONG); j; ) - b[--j] = *p++; - dev->writeBlock( b, sizeof(TQ_LONG) ); - } - return *this; -} -#endif - - -/*! - \overload TQDataStream &TQDataStream::operator<<( TQ_UINT32 i ) - - Writes an unsigned integer, \a i, to the stream as a 32-bit - unsigned integer (TQ_UINT32). Returns a reference to the stream. -*/ - -/*! - \overload - - Writes a 32-bit floating point number, \a f, to the stream using - the standard IEEE754 format. Returns a reference to the stream. -*/ - -TQDataStream &TQDataStream::operator<<( float f ) -{ - CHECK_STREAM_PRECOND - if ( printable ) { // printable data - TQString num = TQString::number((double)f); - dev->writeBlock(num.latin1(), num.length()); - dev->putch('\n'); - } 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; -} - - -/*! - \overload - - Writes a 64-bit floating point number, \a f, to the stream using - the standard IEEE754 format. Returns a reference to the stream. -*/ - -TQDataStream &TQDataStream::operator<<( double f ) -{ - CHECK_STREAM_PRECOND - if ( printable ) { // printable data - TQString num = TQString::number((double)f); - dev->writeBlock(num.latin1(), num.length()); - dev->putch('\n'); - } 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; -} - - -/*! - \overload - - Writes the '\0'-terminated string \a s to the stream and returns a - reference to the stream. - - The string is serialized using writeBytes(). -*/ - -TQDataStream &TQDataStream::operator<<( const char *s ) -{ - if ( !s ) { - *this << (TQ_UINT32)0; - return *this; - } - uint len = tqstrlen( s ) + 1; // also write null terminator - *this << (TQ_UINT32)len; // write length specifier - return writeRawBytes( s, len ); -} - - -/*! - Writes the length specifier \a len and the buffer \a s to the - stream and returns a reference to the stream. - - The \a len is serialized as a TQ_UINT32, followed by \a len bytes - from \a s. Note that the data is \e not encoded. - - \sa writeRawBytes(), readBytes() -*/ - -TQDataStream &TQDataStream::writeBytes(const char *s, uint len) -{ - CHECK_STREAM_PRECOND - *this << (TQ_UINT32)len; // write length specifier - if ( len ) - writeRawBytes( s, len ); - return *this; -} - - -/*! - Writes \a len bytes from \a s to the stream and returns a - reference to the stream. The data is \e not encoded. - - \sa writeBytes(), TQIODevice::writeBlock(), readRawBytes() -*/ - -TQDataStream &TQDataStream::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 TQ_INT8 *p = (TQ_INT8*)s; - while ( len-- ) - *this << *p++; - } - } else { // write data char array - dev->writeBlock( s, len ); - } - return *this; -} - -#endif // TQT_NO_DATASTREAM - -#endif // USE_QT4 |