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


TcpSocket::TcpSocket (auto_ptr <QTcpSocket> socket_, SocketStatus *status_)
    : socket (socket_), status (status_)
{
    Q_ASSERT (socket->state() == QAbstractSocket::UnconnectedState
              || socket->state() == QAbstractSocket::ConnectedState);

    // localhost connections on BSD will be establihsed directly and we don't
    // want our socketConnected() called from within connectToNode() because in
    // this case we could emit connected() from withing connectToNode() and that
    // is not the specified behavior. Therefore we use Qt::QueuedConnection.
    QObject::connect (socket.get(), SIGNAL  (connected()),
                      this,         SLOT    (slotConnected()),
                      Qt::QueuedConnection);
    QObject::connect (socket.get(), SIGNAL  (disconnected()),
                      this,         SLOT    (slotDisconnected()));
    QObject::connect (socket.get(), SIGNAL  (error(QAbstractSocket::SocketError)),
                      this,         SLOT    (slotError()));
    QObject::connect (socket.get(), SIGNAL  (readyRead()),
                      this,         SLOT    (slotRead()));
    QObject::connect (socket.get(), SIGNAL  (bytesWritten (qint64)),
                      this,         SLOT    (slotWritten()));
}

TcpSocket::~TcpSocket()
{
    // Disconnects our slots, we want no slots sending status notifications now:
    socket->disconnect (this);
    if (socket->state() != QAbstractSocket::UnconnectedState)
        abort();
    socket->deleteLater();
    socket.release(); // Qt will delete the object later.
}

void TcpSocket::connectToHost (const QHostAddress &address, quint16 port)
{
    Q_ASSERT (socket->state() == QAbstractSocket::UnconnectedState);
    socket->connectToHost (address, port,
                           QIODevice::ReadWrite | QIODevice::Unbuffered);
}


void TcpSocket::disconnectFromHost()
{
    Q_ASSERT (socket->state() == QAbstractSocket::ConnectedState);
    QMetaObject::invokeMethod (this, "delayedDisconnectFromHost",
                               Qt::QueuedConnection);
}

void TcpSocket::abort()
{
    socket->abort();
}


qint64 TcpSocket::read (char *destination, qint64 size)
{
    Q_ASSERT (destination != 0 && size >= 0);
    return socket->read (destination, size);
}


qint64 TcpSocket::write (const char *source, qint64 size)
{
    Q_ASSERT (source != 0 && size >= 0);
    return socket->write (source, size);
}

void TcpSocket::slotConnected()
{
    status->socketConnected();
}

void TcpSocket::slotDisconnected()
{
    status->socketDisconnected();
}


void TcpSocket::slotError()
{
    QMetaObject::invokeMethod (this, "delayedError", Qt::QueuedConnection);
}

void TcpSocket::slotRead()
{
    status->socketRead();
}

void TcpSocket::slotWritten()
{
    status->socketWritten();
}

void TcpSocket::delayedError()
{
    status->socketError();
}


void TcpSocket::delayedDisconnectFromHost()
{
    socket->disconnectFromHost();
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.