From e16866e072f94410321d70daedbcb855ea878cac Mon Sep 17 00:00:00 2001 From: Timothy Pearson Date: Sun, 6 Nov 2011 15:56:40 -0600 Subject: Actually move the kde files that were renamed in the last commit --- kdecore/kbufferedio.cpp | 309 ------------------------------------------------ 1 file changed, 309 deletions(-) delete mode 100644 kdecore/kbufferedio.cpp (limited to 'kdecore/kbufferedio.cpp') diff --git a/kdecore/kbufferedio.cpp b/kdecore/kbufferedio.cpp deleted file mode 100644 index 951c41244..000000000 --- a/kdecore/kbufferedio.cpp +++ /dev/null @@ -1,309 +0,0 @@ -/* - * This file is part of the KDE libraries - * Copyright (C) 2001 Thiago Macieira - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Library General Public - * License as published by the Free Software Foundation; either - * version 2 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Library General Public License for more details. - * - * You should have received a copy of the GNU Library General Public License - * along with this library; see the file COPYING.LIB. If not, write to - * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, - * Boston, MA 02110-1301, USA. - */ - -#include "config.h" - -#include - -#include -#include -#include "kbufferedio.h" - -/** - * @section impldetails Implementation Details - * - * The KBufferedIO class has two purposes: first, it defines an API on how - * that classes providing buffered I/O should provide. Next, it implements on - * top of that API a generic buffering, that should suffice for most cases. - * - * The buffering implemented consists of two separate buffer areas, one for - * the input (or read) buffer, and one for the output (or write) buffer. Each - * of those buffers is implemented through a QList of QByteArrays instead of - * simply QByteArrays. The idea is that, instead of having one large, contiguous - * buffer area, we have several small ones. Even though this could be seen as - * a waste of memory, it makes our life easier, because we can just append a new - * TQByteArray to the list and not have to worry with copying the rest of the - * buffer, should we need to expand. - * - * This way, we have the capability of unlimited buffering, which can grow to - * the extent of available memory. - * - * For each buffer, we provide three kinds of functions, available as protected - * members: consume, feed and size. The size functions calculate the current - * size of the buffer, by adding each individual TQByteArray size. The feed - * functions are used by the I/O functions that receive data from somewhere, - * i.e., from the system, in the case of the input buffer, and from the user, - * in the case of the output buffer. These two functions are used to give - * the buffers more data. And the consume functions are used by the functions - * that send out data (to the system, for the write buffer, and to the user, - * for the read buffer). - * - * Note that for your own implementation, you can have your readBlock function - * merely call consumeReadBuffer, similarly to peekBlock. As for - * the writeBlock function, you'd call feedWriteBuffer. - * - * Now, the function receiving data from the system will need to simply call - * feedReadBuffer, much in the same way of unreadBlock. The tricky part is - * for the output function. We do not provide a member function that copies - * data from the output buffer into another buffer for sending. We believe that - * would be a waste of resources and CPU time, since you'd have to allocate - * that buffer, copy data into it and then call the OS, which will likely just - * copy data out of it. - * - * Instead, we found it better to leave it to you to access outBuf member - * variable directly and use the buffers there. Should you want to copy that - * into a larger buffer before sending, that's up to you. - * - * Both buffers work in the same way: they're an "array" of buffers, each - * concatenated to the other. All data in all buffers is valid data, except - * for the first TQByteArray, whose valid data starts at inBufIndex/outBufIndex - * bytes from the start. That is, the data starts in the first TQByteArray buffer - * that many bytes from the start and goes on contiguously until the last - * TQByteArray. This has been decided like that because we didn't want to - * create a new TQByteArray of the remaining bytes in the first buffer, after - * a consume operation, because that could take some time. It is faster - * this way, although not really easy. - * - * If you want to take a look at an implementation of a buffered I/O class, - * refer to KExtendedSocket's source code. - */ - -// constructor -KBufferedIO::KBufferedIO() : - inBufIndex(0), outBufIndex(0) -{ - inBuf.setAutoDelete(true); - outBuf.setAutoDelete(true); -} - -// destructor -KBufferedIO::~KBufferedIO() -{ -} - -// sets the buffer sizes -// this implementation doesn't support setting the buffer sizes -// if any parameter is different than -1 or -2, fail -bool KBufferedIO::setBufferSize(int rsize, int wsize /* = -2 */) -{ - if (wsize != -2 && wsize != -1) - return false; - if (rsize != -2 && rsize != -1) - return false; - - return true; -} - -#ifdef USE_QT3 -int KBufferedIO::bytesAvailable() const -#endif // USE_QT3 -#ifdef USE_QT4 -qint64 KBufferedIO::bytesAvailable() const -#endif // USE_QT4 -{ - return readBufferSize(); -} - -#ifdef USE_QT3 -int KBufferedIO::bytesToWrite() const -#endif // USE_QT3 -#ifdef USE_QT4 -qint64 KBufferedIO::bytesToWrite() const -#endif // USE_QT4 -{ - return writeBufferSize(); -} - -// This function will scan the read buffer for a '\n' -bool KBufferedIO::canReadLine() const -{ - if (bytesAvailable() == 0) - return false; // no new line in here - - TQByteArray* buf; - - // scan each TQByteArray for the occurrence of '\n' - TQPtrList &buflist = ((KBufferedIO*)this)->inBuf; - buf = buflist.first(); - char *p = buf->data() + inBufIndex; - int n = buf->size() - inBufIndex; - while (buf != NULL) - { - while (n--) - if (*p++ == '\n') - return true; - buf = buflist.next(); - if (buf != NULL) - { - p = buf->data(); - n = buf->size(); - } - } - - return false; // no new line found -} - -// unreads the current data -// that is, writes into the read buffer, at the beginning -int KBufferedIO::unreadBlock(const char *data, uint len) -{ - return feedReadBuffer(len, data, true); -} - -// -// protected member functions -// - -unsigned KBufferedIO::consumeReadBuffer(unsigned nbytes, char *destbuffer, bool discard) -{ - { - register unsigned u = readBufferSize(); - if (nbytes > u) - nbytes = u; // we can't consume more than there is - } - - TQByteArray *buf; - unsigned copied = 0; - unsigned index = inBufIndex; - - buf = inBuf.first(); - while (nbytes && buf) - { - // should we copy it all? - unsigned to_copy = buf->size() - index; - if (to_copy > nbytes) - to_copy = nbytes; - - if (destbuffer) - memcpy(destbuffer + copied, buf->data() + index, to_copy); - nbytes -= to_copy; - copied += to_copy; - - if (buf->size() - index > to_copy) - { - index += to_copy; - break; // we aren't copying everything, that means that's - // all the user wants - } - else - { - index = 0; - if (discard) - { - inBuf.remove(); - buf = inBuf.first(); - } - else - buf = inBuf.next(); - } - } - - if (discard) - inBufIndex = index; - - return copied; -} - -void KBufferedIO::consumeWriteBuffer(unsigned nbytes) -{ - TQByteArray *buf = outBuf.first(); - if (buf == NULL) - return; // nothing to consume - - if (nbytes < buf->size() - outBufIndex) - // we want to consume less than there is in the first buffer - outBufIndex += nbytes; - else - { - nbytes -= buf->size() - outBufIndex; - outBufIndex = 0; - outBuf.remove(); - - while ((buf = outBuf.current()) != NULL) - if (buf->size() <= nbytes) - { - nbytes -= buf->size(); - outBuf.remove(); - } - else - { - outBufIndex = nbytes; - break; - } - } -} - -unsigned KBufferedIO::feedReadBuffer(unsigned nbytes, const char *buffer, bool atBeginning) -{ - if (nbytes == 0) - return 0; - - TQByteArray *a = new TQByteArray(nbytes); - a->duplicate(buffer, nbytes); - - if (atBeginning) - inBuf.prepend(a); - else - inBuf.append(a); - - return nbytes; -} - -unsigned KBufferedIO::feedWriteBuffer(unsigned nbytes, const char *buffer) -{ - if (nbytes == 0) - return 0; - - TQByteArray *a = new TQByteArray(nbytes); - a->duplicate(buffer, nbytes); - outBuf.append(a); - return nbytes; -} - -unsigned KBufferedIO::readBufferSize() const -{ - unsigned count = 0; - TQByteArray *buf = ((KBufferedIO*)this)->inBuf.first(); - while (buf != NULL) - { - count += buf->size(); - buf = ((KBufferedIO*)this)->inBuf.next(); - } - - return count - inBufIndex; -} - -unsigned KBufferedIO::writeBufferSize() const -{ - unsigned count = 0; - TQByteArray *buf = ((KBufferedIO*)this)->outBuf.first(); - while (buf != NULL) - { - count += buf->size(); - buf = (const_cast(this))->outBuf.next(); - } - - return count - outBufIndex; -} - -void KBufferedIO::virtual_hook( int id, void* data ) -{ KAsyncIO::virtual_hook( id, data ); } - -#include "kbufferedio.moc" -- cgit v1.2.1