1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
|
/****************************************************************************
**
** 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 [email protected].
**
** 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 TQT_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 // TQT_NO_ASYNC_IO
|