Actually move the kde files that were renamed in the last commit

1 files changed, 309 insertions, 0 deletions

diff --git a/tdecore/kbufferedio.cpp b/tdecore/kbufferedio.cpp
new file mode 100644
index 000000000..951c41244
--- /dev/null
+++ b/tdecore/kbufferedio.cpp
@@ -0,0 +1,309 @@
+/*
+ *  This file is part of the KDE libraries
+ *  Copyright (C) 2001 Thiago Macieira <thiago.macieira@kdemail.net>
+ *
+ *  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 <string.h>
+
+#include <tqptrlist.h>
+#include <tqcstring.h>
+#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<TQByteArray> &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<KBufferedIO*>(this))->outBuf.next();
+    }
+
+  return count - outBufIndex;
+}
+
+void KBufferedIO::virtual_hook( int id, void* data )
+{ KAsyncIO::virtual_hook( id, data ); }
+
+#include "kbufferedio.moc"