IpResolvingTransportFactory.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 "IpResolvingTransportFactory.h"
#include "NameResolver.h"
#include "TransportFactoryStatus.h"
#include "Imports.cpp"

IpResolvingTransportFactory::IpResolvingTransportFactory (
                                                TransportFactory *otherFactory,
                                                NameResolver *nameResolver)
 :  otherFactory_ (otherFactory),
    nameResolver_ (nameResolver),
    resolvingStates_(),
    creatingStates_()
{
    Q_ASSERT (otherFactory_ != 0);
}

IpResolvingTransportFactory::~IpResolvingTransportFactory()
{
    // \todo Clean up resolvingStates_ and creatingStates_?
}

void
IpResolvingTransportFactory::createTransport (const Uri &uri,
                                              TransportFactoryStatus *status)
{
    QHostAddress hostAddress (QString (uri.host()));
    if (hostAddress.isNull())
        startNameResolution (uri, status);
    else
        otherFactory_->createTransport (uri, status);
}

void IpResolvingTransportFactory::destroyTransport (Transport *transport)
{
    otherFactory_->destroyTransport (transport);
}

void IpResolvingTransportFactory::transportFactorySucceeded (
                                                    const Uri &uri,
                                                    Transport *transport)
{
    Q_ASSERT (creatingStates_.contains (uri));
    auto_ptr <ResolvingState> state (creatingStates_.take (uri));
    state->status->transportFactorySucceeded (state->uri, transport);
}

void IpResolvingTransportFactory::transportFactoryFailed (const Uri &uri)
{
    Q_ASSERT (creatingStates_.contains (uri));
    // \todo tryCreateTransport() modify it to read creatingStates_
    auto_ptr <ResolvingState> state (creatingStates_.take (uri));
    state->status->transportFactoryFailed (state->uri);
}

void IpResolvingTransportFactory::nameResolverResolvedName (
                                        const QByteArray &host,
                                        const QList <QHostAddress> &addresses)
{
    Q_ASSERT (resolvingStates_.contains (host));
    resolvingStates_.value (host)->addresses = addresses;
    tryCreateTransport (host);
}

void IpResolvingTransportFactory::startNameResolution (
                                            const Uri &uri,
                                            TransportFactoryStatus *status)
{
    QByteArray host = uri.host();
    auto_ptr <ResolvingState> state (new ResolvingState);
    state->uri = uri;
    state->status = status;
    resolvingStates_.insert (host, state.get());
    state.release();
    nameResolver_->resolveName (host, this);
}

void IpResolvingTransportFactory::createFailed (const QByteArray &host)
{
    auto_ptr <ResolvingState> state;
    state.reset (resolvingStates_.take (host));
    state->status->transportFactoryFailed (state->uri);
}

void IpResolvingTransportFactory::tryCreateTransport (const QByteArray &host)
{
    QList <QHostAddress> addresses = resolvingStates_.value (host)->addresses;
    if (addresses.isEmpty())
        createFailed (host);
    else {
        ResolvingState * state = resolvingStates_.value (host);
        Uri uri = state->uri;
        uri.setAuthority (uri.userInfo(),
                          addresses.takeFirst().toString().toLatin1(),
                          uri.port());
        creatingStates_.insert (uri, state);
        resolvingStates_.take (host);
        otherFactory_->createTransport (uri, this);
    }
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.