TcpTransportFactory.cpp

Go to the documentation of this file.

/*

Copyright (C) 2006-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 "TcpTransportFactory.h"
#include "SocketTransport.h"
#include "TcpSocket.h"
#include "TcpSocketBuffer.h"
#include "TransportFactoryStatus.h"
#include "Imports.cpp"

namespace Protocols {
namespace Generics {


class TcpTransport : public SocketTransport
{
public:
    TcpTransport (int readBufferSize, int writeBufferSize,
                  TransportStatus *status)
     :  SocketTransport (&socket, &socketBuffer, status),
        socket (auto_ptr <QTcpSocket> (new QTcpSocket), this),
        socketBuffer (readBufferSize, writeBufferSize)
    {}

private:
    TcpSocket           socket;
    TcpSocketBuffer     socketBuffer;
};

} // namespace Generics
} // namespace Protocols

TcpTransportFactory::TcpTransportFactory()
 :  establishingTransports(), transports()
{
}

TcpTransportFactory::~TcpTransportFactory()
{
    foreach (Transport *transport, establishingTransports.keys())
        delete transport;
    foreach (EstablishingTransport *transport, establishingTransports.values())
        delete transport;
    establishingTransports.clear();

    foreach (Transport *transport, transports)
        delete transport;
    transports.clear();
}

// \todo test buffer sizes are set correctly!
void TcpTransportFactory::createTransport (const Uri &uri,
                                           TransportFactoryStatus *status)
{
    Q_ASSERT (uri.scheme() == "tcp");
    const int readBufferSize = uri.queryItemValue ("rb").toInt();
    Q_ASSERT (readBufferSize > 0);
    const int writeBufferSize = uri.queryItemValue ("wb").toInt();
    Q_ASSERT (writeBufferSize > 0);

    auto_ptr <Transport> transport (
        new TcpTransport (readBufferSize, writeBufferSize, this));
    auto_ptr <EstablishingTransport> establishingTransport (
        new EstablishingTransport);
    establishingTransport->uri = uri;
    establishingTransport->status = status;

    establishingTransports.insert (transport.get(),
                                   establishingTransport.get());

    establishingTransport.release();
    transport.release()->connectToNode (uri);
}

void TcpTransportFactory::destroyTransport (Transport *transport)
{
    Q_ASSERT (transports.contains (transport));
    transports.remove(transport);
    delete transport;
}

void TcpTransportFactory::transportConnected (Transport *transport)
{
    Q_ASSERT (!transports.contains (transport));
    Q_ASSERT (establishingTransports.contains (transport));
    auto_ptr <Transport> connectedTransport (transport);
    auto_ptr <EstablishingTransport> establishingTransport (
        establishingTransports.take (transport));
    transports.insert (transport); // may throw
    connectedTransport.release(); // ownership already passed to transports

    establishingTransport->status->transportFactorySucceeded (
        establishingTransport->uri, transport);
}

void TcpTransportFactory::transportReadyRead (Transport *)
{
    Q_ASSERT (false);
}

void TcpTransportFactory::transportReadyWrite (Transport *)
{
    Q_ASSERT (false);
}

void TcpTransportFactory::transportDisconnected (Transport *transport)
{
    // If transport was already established, then
    // transport->setTransportStatus() must have been called,
    // otherwise we may receive the transportDisconnected notification:
    Q_ASSERT (!transports.contains (transport));
    // We are only supposed to receive the notification for our
    // establishingTransports:
    Q_ASSERT (establishingTransports.contains (transport));
    auto_ptr <Transport> disconnectedTransport (transport);
    auto_ptr <EstablishingTransport> establishingTransport (
        establishingTransports.take (transport));

    establishingTransport->status->transportFactoryFailed (
        establishingTransport->uri);
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.