TcpSocketBuffer.cpp

Go to the documentation of this file.

/*

Copyright (C) 2005-2007 by Peter Dimov.

This file is part of Calitko (http://www.calitko.org).

Calitko is free software you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation either version 2 of the License, or
(at your option) any later version.

Calitko 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with Calitko if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

*/

#include "Qt.h"
#include "TcpSocketBuffer.h"
#include "Socket.h"
#include "Imports.cpp"


TcpSocketBuffer::TcpSocketBuffer (int readBufferSize, int writeBufferSize)
    : readBuffer (0), readSize (0), readStart (0), readEnd (0),
      writeBuffer (0),  writeSize (0), writeStart (0), writeEnd (0),
      writeFlushEnd (0)
{
    Q_ASSERT (readBufferSize >= 0);
    Q_ASSERT (writeBufferSize >= 0);

    setReadBufferSize (readBufferSize);
    setWriteBufferSize (writeBufferSize);
}

TcpSocketBuffer::~TcpSocketBuffer()
{
    delete[] readBuffer;
    delete[] writeBuffer;
}


QByteArray TcpSocketBuffer::peek (int count) const
{
    if (!canRead (count))
        return QByteArray();
    else {
        QByteArray res;
        res.resize (count);
        peek (res.data(), res.size());
        return res;
    }
}


QByteArray TcpSocketBuffer::peekAtMost (int count) const
{
    return peek (std::min (count, readEnd - readStart));
}


QByteArray TcpSocketBuffer::peekTo (const QByteArray &delimiter) const
{
    QByteArray allBytes = peekAll();
    int pos = allBytes.indexOf (delimiter);
    if (pos == -1)
        return QByteArray();
    else
        return allBytes.left (pos + delimiter.size());
}


QByteArray TcpSocketBuffer::peekAll() const
{
    return peek (bytesToRead());
}


QByteArray TcpSocketBuffer::read (int count)
{
    QByteArray res = peek (count);
    purgeReadBuffer (res.size());
    return res;
}


QByteArray TcpSocketBuffer::readAtMost (int count)
{
    QByteArray res = peekAtMost (count);
    purgeReadBuffer (res.size());
    return res;
}


QByteArray TcpSocketBuffer::readTo (const QByteArray &delimiter)
{
    QByteArray res = peekTo (delimiter);
    purgeReadBuffer (res.size());
    return res;
}


QByteArray TcpSocketBuffer::readAll()
{
    QByteArray res = peekAll();
    purgeReadBuffer (res.size());
    return res;
}


void TcpSocketBuffer::tryReadFrom (Socket *socket)
{
    int readSize = 0;
    while ((readSize = nextReadChunkSize()) > 0) {
        char *readBuffer = nextReadChunk();
        qint64 read = socket->read (readBuffer, readSize);
        if (read > 0)
            hasRead (read);
        // If the socket could not read all bytes we requested, try again later.
        if (read < readSize)
            break;
    }
}


bool TcpSocketBuffer::canRead (int count) const
{
    Q_ASSERT (count >= 0);
    return readStart + count <= readEnd;
}


void TcpSocketBuffer::peek (char *destination, int size) const
{
    Q_ASSERT (canRead (size));
    // It's a ring buffer so be careful not to read beyound the array end:
    if (readStart + size <= readSize) {
        memcpy (destination, readBuffer + readStart, size);
    } else {
        // Read the part at the end of the ring buffer array:
        int count = readSize - readStart;
        memcpy (destination, readBuffer + readStart, count);
        // Read the rest from the start of the ring buffer:
        Q_ASSERT (size - count > 0);
        memcpy (destination + count, readBuffer, size - count);
    }
}


void TcpSocketBuffer::purgeReadBuffer (int count)
{
    Q_ASSERT (canRead (count));
    readStart += count;
    // We keep readStart in the range [0, readSize)
    // and readEnd in the range [0, readSize * 2)
    if (readStart >= readSize) {
        readStart -= readSize;
        readEnd -= readSize;
    }
}


void TcpSocketBuffer::setReadBufferSize (int size)
{
    Q_ASSERT (size >= 0);
    char *newBuffer = 0;
    if (size > 0)
        newBuffer = new char [size];
    delete[] readBuffer;
    readBuffer = newBuffer;
    readSize = size;
    readStart = readEnd = 0;
}


int TcpSocketBuffer::readBufferSize() const
{
    return readSize;
}


int TcpSocketBuffer::bytesToRead() const
{
    return readEnd - readStart;
}


char* TcpSocketBuffer::nextReadChunk() const
{
    int readPos = (readEnd >= readSize) ? (readEnd - readSize) : readEnd;
    return readBuffer + readPos;
}


int TcpSocketBuffer::nextReadChunkSize() const
{
    if (readEnd >= readSize)
        return readStart - (readEnd - readSize);
    else
        return readSize - readEnd;
}


void TcpSocketBuffer::hasRead (int count)
{
    Q_ASSERT (count >= 0);
    Q_ASSERT (readEnd + count <= readStart + readSize);
    readEnd += count;
}


bool TcpSocketBuffer::write (const QByteArray &bytes, bool flush)
{
    int size = bytes.size();
    if (!canWrite (size))
        return false;
    write (bytes.data(), size, flush);
    return true;
}


void TcpSocketBuffer::tryWriteTo (Socket *socket)
{
    while (bytesToWrite() > 0) {
        // buffer is responsible to provide only bytes which have been flushed
        char *writeBuffer = nextWriteChunk();
        int writeSize = nextWriteChunkSize();
        qint64 written = socket->write (writeBuffer, writeSize);
        Q_ASSERT (written <= writeSize);
        if (written > 0)
            hasWritten (written);
        // If the buffer cannot take all we gave it, then try again later.
        if (written < writeSize)
            break;
    }
}


bool TcpSocketBuffer::canWrite (int count) const
{
    Q_ASSERT (count >= 0);
    return writeEnd + count <= writeStart + writeSize;
}


void TcpSocketBuffer::write (const char *source, int size, bool flush)
{
    Q_ASSERT (canWrite (size));
    int writePos = (writeEnd >= writeSize) ? (writeEnd - writeSize) : writeEnd;
    if (writePos + size <= writeSize) {
        memcpy (writeBuffer + writeEnd, source, size);
    } else {
        int count = writeSize - writeEnd;
        memcpy (writeBuffer + writePos, source, count);
        Q_ASSERT (size - count > 0);
        memcpy (writeBuffer, source + count, size - count);
    }
    writeEnd += size;
    if (flush)
        writeFlushEnd = writeEnd;
}


void TcpSocketBuffer::setWriteBufferSize (int size)
{
    Q_ASSERT (size >= 0);
    char *newBuffer = 0;
    if (size > 0)
        newBuffer = new char [size];
    delete[] writeBuffer;
    writeBuffer = newBuffer;
    writeSize = size;
    writeStart = writeEnd = writeFlushEnd = 0;
}


int TcpSocketBuffer::writeBufferSize() const
{
    return writeSize;
}


int TcpSocketBuffer::bytesToWrite() const
{
    return writeEnd - writeStart;
}


char * TcpSocketBuffer::nextWriteChunk() const
{
    return writeBuffer + writeStart;
}


int TcpSocketBuffer::nextWriteChunkSize() const
{
    return std::min (writeSize - writeStart, writeFlushEnd - writeStart);
}


void TcpSocketBuffer::hasWritten (int count)
{
    Q_ASSERT (count >= 0);
    Q_ASSERT (writeStart + count <= writeFlushEnd);
    Q_ASSERT (writeFlushEnd <= writeEnd);
    writeStart += count;
    if (writeStart >= writeSize) {
        writeStart -= writeSize;
        writeFlushEnd -= writeSize;
        writeEnd -= writeSize;
    }
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.