loader.h

/*
 * loader.h
 *
 * Copyright (c) 2001, 2002, 2003 Frerich Raabe <raabe@kde.org>
 *
 * This program 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. For licensing and distribution details, check the
 * accompanying file 'COPYING'.
 */
#ifndef LIBRSS_LOADER_H
#define LIBRSS_LOADER_H
 
#include "global.h"
 
class KURL;
 
#include <tqobject.h>
 
namespace TDEIO
{
    class Job;
}
class TDEProcess;
 
namespace RSS
{
    class Document;
 
    class TDE_EXPORT DataRetriever : public TQObject
    {
        TQ_OBJECT
  
        public:
            DataRetriever();
 
            virtual ~DataRetriever();
 
            virtual void retrieveData(const KURL &url) = 0;
 
            virtual int errorCode() const = 0;
 
            virtual void abort() = 0;
        signals:
            void dataRetrieved(const TQByteArray &data, bool success);
 
        private:
            DataRetriever(const DataRetriever &other);
            DataRetriever &operator=(const DataRetriever &other);
    };
 
    class TDE_EXPORT FileRetriever : public DataRetriever
    {
        TQ_OBJECT
  
        public:
            FileRetriever();
 
            virtual ~FileRetriever();
 
            virtual void retrieveData(const KURL &url);
 
            virtual int errorCode() const;
 
            virtual void abort();
 
            static void setUseCache(bool enabled);
            static void setUserAgent(const TQString &ua);
                        static TQString userAgent();
 
        signals:
            void permanentRedirection(const KURL &url);
 
        protected slots:
            void slotTimeout();
 
        private slots:
            void slotData(TDEIO::Job *job, const TQByteArray &data);
            void slotResult(TDEIO::Job *job);
            void slotPermanentRedirection(TDEIO::Job *job, const KURL &fromUrl,
                                                         const KURL &toUrl);
 
        private:
            static bool m_useCache;
 
            FileRetriever(const FileRetriever &other);
            FileRetriever &operator=(const FileRetriever &other);
 
            struct Private;
            Private *d;
    };
 
    class OutputRetriever : public DataRetriever
    {
        TQ_OBJECT
  
        public:
            OutputRetriever();
 
            virtual ~OutputRetriever();
 
            virtual void retrieveData(const KURL &url);
 
            virtual int errorCode() const;
 
            virtual void abort() {}
 
        private slots:
            void slotOutput(TDEProcess *process, char *data, int length);
            void slotExited(TDEProcess *process);
 
        private:
            OutputRetriever(const OutputRetriever &other);
            OutputRetriever &operator=(const OutputRetriever &other);
 
            struct Private;
            Private *d;
    };
 
    class TDE_EXPORT Loader : public TQObject
    {
        TQ_OBJECT
  
        friend class someClassWhichDoesNotExist;
        public:
            static Loader *create();
 
            static Loader *create(TQObject *object, const char *slot);
 
            void loadFrom(const KURL &url, DataRetriever *retriever);
 
            int errorCode() const;
 
            const KURL &discoveredFeedURL() const;
 
            void abort();
 
        signals:
            void loadingComplete(Loader *loader, Document doc, Status status);
 
        private slots:
            void slotRetrieverDone(const TQByteArray &data, bool success);
 
        private:
            Loader();
            Loader(const Loader &other);
            Loader &operator=(const Loader &other);
            ~Loader();
            void discoverFeeds(const TQByteArray &data);
 
            struct Private;
            Private *d;
    };
}
 
#endif // LIBRSS_LOADER_H