main.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 "MainWindow.h"
#include <QCDEStyle>
#include <QMotifStyle>
#include <QPlastiqueStyle>
#include <QWindowsXPStyle>


#include "Protocols/Http/ClientHttpSession.h"
#include "Protocols/Http/ClientHttpSessionFactory.h"
#include "Protocols/Http/ClientHttpSessionStatus.h"
#include "Protocols/Http/HeaderBase.h"
#include "Protocols/Http/ResponseHeader.h"
#include "Protocols/Generics/IpResolvingTransportFactory.h"
#include "Protocols/Generics/TcpTransportFactory.h"
#include "Protocols/Generics/QtNameResolver.h"

#include <iostream>

class MemoryFile : public Protocols::Http::File
{
public:
    bool write (const QByteArray &bytes, bool = true)
    {
        bytes_ += bytes;
        return true;
    }

    QByteArray bytes_;
};

using Protocols::Generics::Data;
using Protocols::Generics::IpResolvingTransportFactory;
using Protocols::Generics::TcpTransportFactory;
using Protocols::Generics::QtNameResolver;
using Protocols::Http::ClientHttpSession;
using Protocols::Http::ClientHttpSessionFactory;
using Protocols::Http::HeaderBase;
using Protocols::Http::ResponseHeader;
using Utils::Uri;

//#include "3rdParty/cppunit/Exception.h"
#include <exception>

class TesterApp : QCoreApplication
{

    static int exec()
    {
        TesterApp *app = dynamic_cast <TesterApp *> (
                                                QCoreApplication::instance());
        Q_ASSERT (app != 0); // app does not have the correct type.
        app->exec();
        if (app->cppUnitException)
            throw std::exception (app->cppUnitException);
    }

private:
    //CPPUNIT_NS::Exception cppUnitException;
    std::exception      cppUnitException;
};

class HttpDownloader : public Protocols::Http::ClientHttpSessionFactoryStatus,
                       public Protocols::Http::ClientHttpSessionStatus
{
    QtNameResolver              qtNameResolver_;
    TcpTransportFactory         tcpTransportFactory_;
    IpResolvingTransportFactory ipResolvingTransportFactory_;
    ClientHttpSessionFactory    clientHttpSessionFactory_;
    ClientHttpSession           *session_;
    MemoryFile                  memoryFile;

public:
    HttpDownloader()
     :  qtNameResolver_(),
        tcpTransportFactory_(),
        ipResolvingTransportFactory_ (&tcpTransportFactory_, &qtNameResolver_),
        clientHttpSessionFactory_ (&ipResolvingTransportFactory_),
        session_ (0),
        memoryFile()
    {
    }

    ~HttpDownloader()
    {
    }

    void download (const QByteArray &url)
    {
        clientHttpSessionFactory_.createSession (Uri::fromUnencoded (url), this, this);
    }

    // Interface  ClientHttpSessionFactoryStatus:
    void clientHttpSessionFactorySucceeded (const Uri &uri,
                                            ClientHttpSession *session)
    {
        session_ = session;
        session_->open(); // Enables reading and writing.
        session_->get (uri, &memoryFile);
    }

    void clientHttpSessionFactoryFailed (const Uri &)
    {
        qDebug() << "FAILED to open session!";
        done();
    }

    // Interface  ClientHttpSessionStatus:
    void clientHttpSessionResponseStarted (const ResponseHeader &header)
    {
        qDebug() << "Response Header:";
        qDebug() << header.toRawBytes();
    }

    void clientHttpSessionResponseFinished (const HeaderBase &header)
    {
        qDebug() << "FINISHED";
        qDebug() << header.toRawBytes();
        qDebug() << "Response DATA:";
        std::cout.write (memoryFile.bytes_.constData(), memoryFile.bytes_.size());
        session_->close();
    }

    void clientHttpSessionInvaidResponse (const Data &)
    {
        qDebug() << "INVALID RESPONSE";
        done();
    }

    void clientHttpSessionClosing()
    {
        qDebug() << "Closing session...";
    }

    void clientHttpSessionClosed()
    {
        qDebug() << "Session closed.";
        done();
    }

private:
    void done()
    {
        if (session_ != 0)
            clientHttpSessionFactory_.destroySession (session_);
        QCoreApplication::exit(0);
    }
};

int main (int argc, char *argv[])
{
    QCoreApplication app (argc, argv);
    {
        HttpDownloader downloader;
        //downloader.download ("http://www.calitko.org"); // requires chunked
        downloader.download ("http://bzr.calitko.org/developers/peter/trac-0.10.3-changeset.request.parsing.patch");
        int ret =  app.exec();
        qDebug() << "app.exec() returned" << ret;
    }
    qDebug() << "before the second QCoreApplication ctor";
    {
        HttpDownloader downloader;
        //downloader.download ("http://www.calitko.org"); // requires chunked
        downloader.download ("http://bzr.calitko.org/developers/peter/trac-0.10.3-changeset.request.parsing.patch");
        int ret =  app.exec();
        qDebug() << "app.exec() returned" << ret;
    }
    return 0;
}

int main_old(int argc, char *argv[])
{
    QApplication app(argc, argv);
//  QApplication::setStyle(new QCDEStyle());
//  QApplication::setStyle(new QMotifStyle());
    QApplication::setStyle(new QPlastiqueStyle());
//  QApplication::setStyle(new QWindowsXPStyle());
    QApplication::setWindowIcon (QIcon ("Icons/Trojan.png"));
    MainWindow window;
    window.show();
    return app.exec();
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.