diff options
Diffstat (limited to 'tqtinterface/qt4/src/tools/tqbuffer.h~')
| -rw-r--r-- | tqtinterface/qt4/src/tools/tqbuffer.h~ | 219 |
1 files changed, 219 insertions, 0 deletions
diff --git a/tqtinterface/qt4/src/tools/tqbuffer.h~ b/tqtinterface/qt4/src/tools/tqbuffer.h~ new file mode 100644 index 0000000..c939e50 --- /dev/null +++ b/tqtinterface/qt4/src/tools/tqbuffer.h~ @@ -0,0 +1,219 @@ +/**************************************************************************** +** +** Definition of TQBuffer class +** +** Created : 930812 +** +** 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. +** +**********************************************************************/ + +#ifndef TQBUFFER_H +#define TQBUFFER_H + +#include "tqtglobaldefines.h" + +#ifndef TQT_H +#include "tqiodevice.h" +#include "tqstring.h" +#endif // TQT_H + +#ifdef USE_QT4 + +#include <Qt/qbuffer.h> + +#endif // USE_QT4 + +#ifdef USE_QT4 + +class TQ_EXPORT TQBuffer : public QBuffer +{ +public: +#if defined(TQT_ABI_QT4) + typedef TQ_LLONG Offset; +#else + typedef TQ_ULONG Offset; +#endif + + #warning Please remember that TQByteArray is no longer explicitly shared. If you get weird crashes while using TQt stream objects please see tqbuffer.h line 69 + // NOTE: + // QByteArray was explicitly shared in Qt3 + // This is no longer the case in Qt4 + // If you get weird crashes inside TQBuffer, it probably means you did something like this: + // + // main() { + // aFunction(); + // otherFunction(); + // } + // + // aFunction() { + // TQBuffer m_Buffer(QByteArray()); + // } + // + // otherFunction() { + // m_Buffer.putch('H'); + // } + // + // The QByteArray object was created within aFunction, but as it went out of scope it was destroyed before otherFunction was called + // Therefore, the TQBuffer's internal reference to the TQByteArray was invalid at the time putch() was called + // You could do this instead: + // + // aFunction() { + // TQBuffer m_Buffer(); + // m_Buffer.tqsetBufferFromCopy(QByteArray()); + // } + + TQBuffer() : QBuffer() {} + TQBuffer( TQByteArray &ba ) : QBuffer( &ba, 0 ) {} + TQBuffer( const TQByteArray &ba ) : QBuffer( const_cast<TQByteArray*>(&ba), 0 ) {} +// TQBuffer( TQByteArray ba ) : QBuffer(), internal_ba_copy(ba) { QBuffer::setBuffer(&internal_ba_copy); } // Make a copy of ba + + inline int state() const { return isOpen() ? 0x1000 : 0; } + inline int mode() const { return (int) openMode(); } + inline int flags() const { return (int) openMode(); } + inline bool tqopen( int mode ) { return open((OpenModeFlag)mode); } + + inline Offset at() const { return pos(); } + inline bool at(Offset offset) { return seek(offset); } + inline Offset tqat() const { return pos(); } + inline bool tqat(Offset offset) { return seek(offset); } + +// virtual inline qint64 readBlock(char *data, quint64 maxlen) { return read(data, maxlen); } +// virtual inline qint64 writeBlock(const char *data, quint64 len) { return write(data, len); } +// virtual inline qint64 writeBlock(const QByteArray &data) { return write(data); } + inline qint64 readBlock(char *data, quint64 maxlen) { return read(data, maxlen); } + inline qint64 writeBlock(const char *data, quint64 len) { return write(data, len); } + inline qint64 writeBlock(const QByteArray &data) { return write(data); } + +// virtual inline qint64 readData ( char * data, qint64 maxSize ) { return readBlock(data, maxSize); } +// virtual inline qint64 writeData ( const char * data, qint64 maxSize ) { return writeBlock(data, maxSize); } + + inline int getch() { char c; return getChar(&c) ? int(uchar(c)) : -1; } + inline int putch(int c) { return putChar(char(c)) ? int(uchar(c)) : -1; } + inline int ungetch(int c) { ungetChar(uchar(c)); return c; } + + inline bool isDirectAccess() const { return !isSequential(); } + inline bool isSequentialAccess() const { return isSequential(); } + inline bool isCombinedAccess() const { return false; } + inline bool isBuffered() const { return true; } + inline bool isRaw() const { return false; } + inline bool isSynchronous() const { return true; } + inline bool isAsynchronous() const { return false; } + inline bool isTranslated() const { return (openMode() & Text) != 0; } + inline bool isInactive() const { return !isOpen(); } + + inline TQByteArray &buffer() { return static_cast<TQByteArray&>(QBuffer::buffer()); } + inline bool setBuffer( TQByteArray &tqba ) { if (isOpen() == TRUE) return FALSE; QBuffer::setBuffer(&tqba); return TRUE; } + inline bool tqsetBufferFromCopy( TQByteArray tqba ) { if (isOpen() == TRUE) return FALSE; internal_ba_copy = tqba; QBuffer::setBuffer(&internal_ba_copy); return TRUE; } +// inline bool setBuffer( TQByteArray tqba ) { if (isOpen() == TRUE) return FALSE; internal_ba_copy = tqba; QBuffer::setBuffer(&internal_ba_copy); return TRUE; } + +public: + typedef int Status; + Status status() const { +#if !defined(QT_NO_QOBJECT) + const QFile *f = qobject_cast<const QFile *>(this); + if (f) return (int) f->error(); +#endif + return isOpen() ? 0 /* IO_Ok */ : 8 /* IO_UnspecifiedError */; + } + void resetStatus() { +#if !defined(QT_NO_QOBJECT) + QFile *f = qobject_cast<QFile *>(this); + if (f) f->unsetError(); +#endif + } + + void setqStatus( int ) { std::cout << "[WARNING] TQBuffer::setqStatus() UNIMPLEMENTED\n\r"; } + void resetqStatus() { resetStatus(); } + +private: + TQByteArray internal_ba_copy; +}; + +#else // USE_QT4 + +class TQ_EXPORT TQBuffer : public TQIODevice +{ +public: + TQBuffer(); + TQBuffer( TQByteArray ); + ~TQBuffer(); + + TQByteArray buffer() const; + bool setBuffer( TQByteArray ); + + bool open( int ); + void close(); + void flush(); + + Offset size() const; + Offset at() const; + bool at( Offset ); + + TQ_LONG readBlock( char *p, TQ_ULONG ); + TQ_LONG writeBlock( const char *p, TQ_ULONG ); + TQ_LONG writeBlock( const TQByteArray& data ) + { return TQIODevice::writeBlock(data); } + TQ_LONG readLine( char *p, TQ_ULONG ); + + int getch(); + int putch( int ); + int ungetch( int ); + +protected: + TQByteArray a; + +private: + uint a_len; + uint a_inc; + +private: // Disabled copy constructor and operator= +#if defined(TQ_DISABLE_COPY) + TQBuffer( const TQBuffer & ); + TQBuffer &operator=( const TQBuffer & ); +#endif +}; + + +inline TQByteArray TQBuffer::buffer() const +{ return a; } + +inline TQIODevice::Offset TQBuffer::size() const +{ return (Offset)a.size(); } + +inline TQIODevice::Offset TQBuffer::at() const +{ return ioIndex; } + +#endif // USE_QT4 + +#endif // TQBUFFER_H |