/**************************************************************************** ** ** Implementation of asynchronous I/O classes ** ** Created : 970617 ** ** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved. ** ** This file is part of the kernel 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 "ntqasyncio.h" #include "ntqiodevice.h" #include <stdlib.h> #ifndef QT_NO_ASYNC_IO /*! \class TQAsyncIO ntqasyncio.h \obsolete \brief The TQAsyncIO class encapsulates I/O asynchronicity. The TQt classes for asynchronous input/output provide a simple mechanism to allow large files or slow data sources to be processed without using large amounts of memory or blocking the user interface. This facility is used in TQt to drive animated images. See TQImageConsumer. */ /*! Destroys the async IO object. */ TQAsyncIO::~TQAsyncIO() { } /*! Ensures that only one object, \a obj and function, \a member, can respond to changes in readiness. */ void TQAsyncIO::connect(TQObject* obj, const char *member) { signal.disconnect(0, 0); signal.connect(obj, member); } /*! Derived classes should call this when they change from being unready to ready. */ void TQAsyncIO::ready() { signal.activate(); } /*! \class TQDataSink ntqasyncio.h \obsolete \brief The TQDataSink class is an asynchronous consumer of data. A data sink is an object which receives data from some source in an asynchronous manner. This means that at some time not determined by the data sink, blocks of data are given to it from processing. The data sink is able to limit the maximum size of such blocks which it is currently able to process. \sa TQAsyncIO, TQDataSource, TQDataPump */ /*! \fn int TQDataSink::readyToReceive() The data sink should return a value indicating how much data it is ready to consume. This may be 0. */ /*! This should be called whenever readyToReceive() might have become non-zero. It is merely calls TQAsyncIO::ready() if readyToReceive() is non-zero. */ void TQDataSink::maybeReady() { if (readyToReceive()) ready(); } /*! \fn void TQDataSink::receive(const uchar*, int count) This function is called to provide data for the data sink. The \a count will be no more than the amount indicated by the most recent call to readyToReceive(). The sink must use all the provided data. */ /*! \fn void TQDataSink::eof() This function will be called when no more data is available for processing. */ /*! \class TQDataSource ntqasyncio.h \obsolete \brief The TQDataSource class is an asynchronous producer of data. A data source is an object which provides data from some source in an asynchronous manner. This means that at some time not determined by the data source, blocks of data will be taken from it for processing. The data source is able to limit the maximum size of such blocks which it is currently able to provide. \sa TQAsyncIO, TQDataSink, TQDataPump */ /*! \fn int TQDataSource::readyToSend() The data source should return a value indicating how much data it is ready to provide. This may be 0. If the data source knows it will never be able to provide any more data (until after a rewind()), it may return -1. */ /*! This should be called whenever readyToSend() might have become non-zero. It is merely calls TQAsyncIO::ready() if readyToSend() is non-zero. */ void TQDataSource::maybeReady() { if (readyToSend()) ready(); } /*! \fn void TQDataSource::sendTo(TQDataSink*, int count) This function is called to extract data from the source, by sending it to the given data sink. The \a count will be no more than the amount indicated by the most recent call to readyToSend(). The source must use all the provided data, and the sink will be prepared to accept at least this much data. */ /*! This function should return TRUE if the data source can be rewound. The default returns FALSE. */ bool TQDataSource::rewindable() const { return FALSE; } /*! If this function is called with \a on set to TRUE, and rewindable() is TRUE, then the data source must take measures to allow the rewind() function to subsequently operate as described. If rewindable() is FALSE, the function should call TQDataSource::enableRewind(), which aborts with a tqFatal() error. For example, a network connection may choose to use a disk cache of input only if rewinding is enabled before the first buffer-full of data is discarded, returning FALSE in rewindable() if that first buffer is discarded. */ void TQDataSource::enableRewind( bool /* on */ ) { tqFatal( "Attempted to make unrewindable TQDataSource rewindable" ); } /*! This function rewinds the data source. This may only be called if enableRewind(TRUE) has been previously called. */ void TQDataSource::rewind() { tqFatal("Attempted to rewind unrewindable TQDataSource"); } /*! \class TQIODeviceSource ntqasyncio.h \obsolete \brief The TQIODeviceSource class is a TQDataSource that draws data from a TQIODevice. This class encapsulates retrieving data from a TQIODevice (such as a TQFile). */ /*! Constructs a TQIODeviceSource from the TQIODevice \a device. The TQIODevice \e must be dynamically allocated, becomes owned by the TQIODeviceSource, and will be deleted when the TQIODeviceSource is destroyed. \a buffer_size determines the size of buffering to use between asynchronous operations. The higher the \a buffer_size, the more efficient, but the less interleaved the operation will be with other processing. */ TQIODeviceSource::TQIODeviceSource(TQIODevice* device, int buffer_size) : buf_size(buffer_size), buffer(new uchar[buf_size]), iod(device), rew(FALSE) { } /*! Destroys the TQIODeviceSource, deleting the TQIODevice from which it was constructed. */ TQIODeviceSource::~TQIODeviceSource() { delete iod; delete [] buffer; } /*! Ready until end-of-file. */ int TQIODeviceSource::readyToSend() { if ( iod->status() != IO_Ok || !(iod->state() & IO_Open) ) return -1; int n = TQMIN((uint)buf_size, iod->size()-iod->at()); // ### not 64-bit safe // ### not large file safe return n ? n : -1; } /*! Reads a block of data and sends up to \a n bytes to the \a sink. */ void TQIODeviceSource::sendTo(TQDataSink* sink, int n) { iod->readBlock((char*)buffer, n); sink->receive(buffer, n); } /*! All TQIODeviceSource's are rewindable. */ bool TQIODeviceSource::rewindable() const { return TRUE; } /*! If \a on is set to TRUE then rewinding is enabled. No special action is taken. If \a on is set to FALSE then rewinding is disabled. */ void TQIODeviceSource::enableRewind(bool on) { rew = on; } /*! Calls reset() on the TQIODevice. */ void TQIODeviceSource::rewind() { if (!rew) { TQDataSource::rewind(); } else { iod->reset(); ready(); } } /*! \class TQDataPump ntqasyncio.h \obsolete \brief The TQDataPump class moves data from a TQDataSource to a TQDataSink during event processing. For a TQDataSource to provide data to a TQDataSink, a controller must exist to examine the TQDataSource::readyToSend() and TQDataSink::readyToReceive() methods and respond to the TQASyncIO::activate() signal of the source and sink. One very useful way to do this is interleaved with other event processing. TQDataPump provides this - create a pipe between a source and a sink, and data will be moved during subsequent event processing. Note that each source can only provide data to one sink and each sink can only receive data from one source (although it is quite possible to write a multiplexing sink that is multiple sources). */ /*! Constructs a TQDataPump to move data from a given \a data_source to a given \a data_sink. */ TQDataPump::TQDataPump(TQDataSource* data_source, TQDataSink* data_sink) : source(data_source), sink(data_sink) { source->connect(this, SLOT(kickStart())); sink->connect(this, SLOT(kickStart())); connect(&timer, SIGNAL(timeout()), this, SLOT(tryToPump())); timer.start(0, TRUE); } void TQDataPump::kickStart() { if (!timer.isActive()) { interval = 0; timer.start(0, TRUE); } } void TQDataPump::tryToPump() { int supply, demand; supply = source->readyToSend(); demand = sink->readyToReceive(); if (demand <= 0) { return; } interval = 0; if (supply < 0) { // All done (until source signals change in readiness) sink->eof(); return; } if (!supply) return; source->sendTo(sink, TQMIN(supply, demand)); timer.start(0, TRUE); } #endif // QT_NO_ASYNC_IO