summaryrefslogtreecommitdiffstats
path: root/experimental/tqtinterface/qt4/src/tools/tqdatastream.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'experimental/tqtinterface/qt4/src/tools/tqdatastream.cpp')
-rw-r--r--experimental/tqtinterface/qt4/src/tools/tqdatastream.cpp1176
1 files changed, 1176 insertions, 0 deletions
diff --git a/experimental/tqtinterface/qt4/src/tools/tqdatastream.cpp b/experimental/tqtinterface/qt4/src/tools/tqdatastream.cpp
new file mode 100644
index 000000000..bf9955ac1
--- /dev/null
+++ b/experimental/tqtinterface/qt4/src/tools/tqdatastream.cpp
@@ -0,0 +1,1176 @@
+/****************************************************************************
+**
+** 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
generated by cgit v1.2.1 (git 2.18.0) at 2024-11-09 06:03:17 +0000