SocketTransport.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 "SocketTransport.h"
#include "Imports.cpp"


SocketTransport::SocketTransport (Socket *socketToUse,
                                  SocketBuffer *socketBufferToUse,
                                  TransportStatus *statusReceiver)
    : socket (socketToUse),
      socketBuffer (socketBufferToUse),
      status (statusReceiver),
      state (DisconnectedState),
      hasCalledWriteBufferToSocket (false),
      hasCalledReadBufferFromSocket (false)
{
}


SocketTransport::~SocketTransport()
{
}


void SocketTransport::connectToNode (const Uri &nodeAddress)
{
    Q_ASSERT (state == DisconnectedState);

    QHostAddress hostAddress (QString (nodeAddress.host()));
    qint16 port = nodeAddress.port().toUShort();
    Q_ASSERT (!hostAddress.isNull());
    Q_ASSERT (port != 0);

    state = ConnectingState;
    socket->connectToHost (hostAddress, port);
}


void SocketTransport::disconnectFromNode()
{
    Q_ASSERT (state == ConnectedState);

    state = DisconnectingState;
    socket->disconnectFromHost();
}


void SocketTransport::abort()
{
    if (state != DisconnectedState) {
        state = DisconnectingState;
        socket->abort();
    }
}


void SocketTransport::socketConnected()
{
    // The connected() signal should be emitted only once!
    if (state == ConnectingState) {
        state = ConnectedState;
        status->transportConnected (this);
    }
}


void SocketTransport::socketDisconnected()
{
    // The disconnected() signal should be emitted only once!
    if (state != DisconnectedState) {
        state = DisconnectedState;
        status->transportDisconnected (this);
    }
}


void SocketTransport::socketError()
{
    // \todo this if should be analysed. Check exactly how QTcpSocket and
    // QUdpSocket behave! Does abort() emit disconnected() if a connection
    // was never established? The integration test indicates the if
    // is correct...
    if (state == ConnectingState) {
        abort();
        socketDisconnected();
    }
    if (state != DisconnectedState)
        abort();
}


void SocketTransport::socketRead()
{
    Q_ASSERT (state == ConnectedState);
    tryReadBufferFromSocket (true);
}


void SocketTransport::socketWritten()
{
    Q_ASSERT (state == ConnectedState);
    tryWriteBufferToSocket (true);
}

bool SocketTransport::canRead (int count) const
{
    Q_ASSERT (state == ConnectedState || state == DisconnectingState);
    return socketBuffer->canRead (count);
}

QByteArray SocketTransport::peek (int count) const
{
    Q_ASSERT (state == ConnectedState || state == DisconnectingState);
    return socketBuffer->peek (count);
}

QByteArray SocketTransport::peekAtMost (int count) const
{
    Q_ASSERT (state == ConnectedState || state == DisconnectingState);
    return socketBuffer->peekAtMost (count);
}

QByteArray SocketTransport::peekTo (const QByteArray &delimiter) const
{
    Q_ASSERT (state == ConnectedState || state == DisconnectingState);
    return socketBuffer->peekTo (delimiter);
}

QByteArray SocketTransport::peekAll() const
{
    Q_ASSERT (state == ConnectedState || state == DisconnectingState);
    return socketBuffer->peekAll();
}

QByteArray SocketTransport::read (int count)
{
    Q_ASSERT (state == ConnectedState || state == DisconnectingState);
    QByteArray bytes = socketBuffer->read (count);
    tryReadBufferFromSocket (false); // must be the same in all read variants!
    return bytes;
}

QByteArray SocketTransport::readAtMost (int count)
{
    Q_ASSERT (state == ConnectedState || state == DisconnectingState);
    QByteArray bytes = socketBuffer->readAtMost (count);
    tryReadBufferFromSocket (false); // must be the same in all read variants!
    return bytes;
}

QByteArray SocketTransport::readTo (const QByteArray &delimiter)
{
    Q_ASSERT (state == ConnectedState || state == DisconnectingState);
    QByteArray bytes = socketBuffer->readTo (delimiter);
    tryReadBufferFromSocket (false); // must be the same in all read variants!
    return bytes;
}

QByteArray SocketTransport::readAll()
{
    Q_ASSERT (state == ConnectedState || state == DisconnectingState);
    QByteArray bytes = socketBuffer->readAll();
    tryReadBufferFromSocket (false); // must be the same in all read variants!
    return bytes;
}

bool SocketTransport::canWrite (int count) const
{
    Q_ASSERT (state == ConnectedState);
    return socketBuffer->canWrite (count);
}

bool SocketTransport::write (const QByteArray &bytes, bool flush)
{
    Q_ASSERT (state == ConnectedState);
    bool hasWritten = socketBuffer->write (bytes, flush);
    // \todo Should we schedule a delayed call to tryWriteBufferToSocket()?
    // This way we could buffer more and then pass all to the OS at once -
    // could improve network performance especially if we write() small chunks
    // at a time.
    tryWriteBufferToSocket (false);
    return hasWritten;
}

// NodeAddress SocketTransport::ownNodeAddress() const
// {
//  return NodeAddress(); // \todo
// }
//
// NodeAddress SocketTransport::remoteNodeAddress() const
// {
//  return NodeAddress(); // \todo
// }

void SocketTransport::tryWriteBufferToSocket (bool canSendReadyWrite)
{
    if (!hasCalledWriteBufferToSocket) {
        hasCalledWriteBufferToSocket = true;

        socketBuffer->tryWriteTo (socket);

        hasCalledWriteBufferToSocket = false;

        if (canSendReadyWrite)
            status->transportReadyWrite (this);
    }
}

void SocketTransport::tryReadBufferFromSocket (bool canSendReadyRead)
{
    if (!hasCalledReadBufferFromSocket) {
        hasCalledReadBufferFromSocket = true;

        socketBuffer->tryReadFrom (socket);

        hasCalledReadBufferFromSocket = false;

        if (canSendReadyRead)
            status->transportReadyRead (this);
    }
}

void SocketTransport::setTransportStatus (TransportStatus *newStatus)
{
    status = newStatus;
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.