verifier.h

Go to the documentation of this file.

/**************************************************************************
*   Copyright (C) 2009-2011 Matthias Fuchs <mat69@gmx.net>                *
*                                                                         *
*   This program 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.                                   *
*                                                                         *
*   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.  See the         *
*   GNU General Public License for more details.                          *
*                                                                         *
*   You should have received a copy of the GNU General Public License     *
*   along with this program; if not, write to the                         *
*   Free Software Foundation, Inc.,                                       *
*   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA .        *
***************************************************************************/

#ifndef VERIFIER_H
#define VERIFIER_H

#include <kio/global.h>
#include <KUrl>

#include <QtCore/QModelIndex>
#include <QtCore/QHash>
#include <QtCore/QStringList>

#include "../kget_export.h"

class QDomElement;
class QFile;
class TransferHandler;
class VerificationModel;
class VerifierPrivate;
typedef QPair<QString, QString> Checksum;


class KGET_EXPORT PartialChecksums
{
    public:
        PartialChecksums()
          : m_length(0)
        {
        }

        PartialChecksums(KIO::filesize_t len, const QStringList &sums)
          : m_length(len), m_checksums(sums)
        {
        }

        bool isValid() const {return (length() && m_checksums.count());}

        KIO::filesize_t length() const {return m_length;}
        void setLength(KIO::filesize_t length) {m_length = length;}

        QStringList checksums() const {return m_checksums;}
        void setChecksums(const QStringList &checksums) {m_checksums = checksums;}

    private:
        KIO::filesize_t m_length;
        QStringList m_checksums;
};

Q_DECLARE_METATYPE(PartialChecksums)

class KGET_EXPORT Verifier : public QObject
{
    Q_OBJECT

    public:
        explicit Verifier(const KUrl &dest, QObject *parent = 0);
        ~Verifier();

        enum VerificationStatus
        {
            NoResult, //either not tried, or not enough information
            NotVerified,
            Verified
        };

        enum ChecksumStrength
        {
            Weak,
            Strong,
            Strongest
        };

        QString dBusObjectPath() const;

        KUrl destination() const;
        void setDestination(const KUrl &destination);//TODO handle the case when m_thread is working, while the file gets moved

        VerificationStatus status() const;

        static QStringList supportedVerficationTypes();

        static int diggestLength(const QString &type);

        static bool isChecksum(const QString &type, const QString &checksum);

        static QString cleanChecksumType(const QString &type);

        static QString checksum(const KUrl &dest, const QString &type, bool *abortPtr);

        static PartialChecksums partialChecksums(const KUrl &dest, const QString &type, KIO::filesize_t length = 0, bool *abortPtr = 0);

        bool isVerifyable() const;

        bool isVerifyable(const QModelIndex &index) const;

        void verify(const QModelIndex &index = QModelIndex());

        void brokenPieces() const;

        void addChecksum(const QString &type, const QString &checksum, int verified = 0);

        void addChecksums(const QHash<QString, QString> &checksums);

        void addPartialChecksums(const QString &type, KIO::filesize_t length, const QStringList &checksums);

        KIO::filesize_t partialChunkLength() const;

        Checksum availableChecksum(ChecksumStrength strength) const;

        QList<Checksum> availableChecksums() const;

        QPair<QString, PartialChecksums*> availablePartialChecksum(Verifier::ChecksumStrength strength) const;

        VerificationModel *model();

        void save(const QDomElement &element);
        void load(const QDomElement &e);

    signals:
        void verified(bool verified);

       void brokenPieces(const QList<KIO::fileoffset_t> &offsets, KIO::filesize_t length);

    private slots:
        void changeStatus(const QString &type, bool verified);

    private:
        VerifierPrivate *const d;

        friend class VerifierPrivate;
};

#endif //VERIFIER_H