QGCCompressionJob.h

Go to the documentation of this file.

#pragma once
 
 
#include "QGCCompression.h"
 
#include <atomic>
#include <memory>
#include <QtCore/QFuture>
#include <QtCore/QFutureWatcher>
#include <QtCore/QObject>
 
class QGCCompressionJob : public QObject
{
    Q_OBJECT
    Q_DISABLE_COPY_MOVE(QGCCompressionJob)
 
    
    Q_PROPERTY(qreal progress READ progress NOTIFY progressChanged FINAL)
 
    
    Q_PROPERTY(bool running READ isRunning NOTIFY runningChanged FINAL)
 
    
    Q_PROPERTY(QString errorString READ errorString NOTIFY errorStringChanged FINAL)
 
    
    Q_PROPERTY(QString sourcePath READ sourcePath NOTIFY sourcePathChanged FINAL)
 
    
    Q_PROPERTY(QString outputPath READ outputPath NOTIFY outputPathChanged FINAL)
 
public:
    enum class Operation {
        None,
        ExtractArchive,
        ExtractArchiveAtomic,
        DecompressFile,
        ExtractFile,
        ExtractFiles
    };
    Q_ENUM(Operation)
 
    explicit QGCCompressionJob(QObject *parent = nullptr);
    ~QGCCompressionJob() override;
 
    // Property getters
    qreal progress() const { return _progress; }
    bool isRunning() const { return _running; }
    QString errorString() const { return _errorString; }
    QString sourcePath() const { return _sourcePath; }
    QString outputPath() const { return _outputPath; }
 
    Operation currentOperation() const { return _operation; }
 
    QFuture<bool> future() const { return _future; }
 
    // ========================================================================
    // Static Async Methods (return QFuture directly)
    // ========================================================================
 
    static QFuture<bool> extractArchiveAsync(const QString &archivePath,
                                              const QString &outputDirectoryPath,
                                              qint64 maxBytes = 0);
 
    static QFuture<bool> decompressFileAsync(const QString &inputPath,
                                              const QString &outputPath = QString(),
                                              qint64 maxBytes = 0);
 
public slots:
    void extractArchive(const QString &archivePath, const QString &outputDirectoryPath,
                        qint64 maxBytes = 0);
 
    void extractArchiveAtomic(const QString &archivePath, const QString &outputDirectoryPath,
                              qint64 maxBytes = 0);
 
    void decompressFile(const QString &inputPath, const QString &outputPath = QString(),
                        qint64 maxBytes = 0);
 
    void extractFile(const QString &archivePath, const QString &fileName,
                     const QString &outputPath);
 
    void extractFiles(const QString &archivePath, const QStringList &fileNames,
                      const QString &outputDirectoryPath);
 
    void cancel();
 
signals:
    void progressChanged(qreal progress);
 
    void runningChanged(bool running);
 
    void finished(bool success);
 
    void errorStringChanged(const QString &errorString);
 
    void sourcePathChanged(const QString &sourcePath);
 
    void outputPathChanged(const QString &outputPath);
 
private slots:
    void _onProgressValueChanged(int progressValue);
    void _onFutureFinished();
 
private:
    using WorkFunction = std::function<bool(QGCCompression::ProgressCallback)>;
 
    void _startOperation(Operation op, const QString &source, const QString &output,
                         WorkFunction work);
    void _setProgress(qreal progress);
    void _setRunning(bool running);
    void _setErrorString(const QString &error);
 
    static QFuture<bool> _runWithProgress(WorkFunction work,
                                          const std::shared_ptr<std::atomic_bool> &cancelRequested);
 
    QFutureWatcher<bool> *_watcher = nullptr;
    QFuture<bool> _future;
 
    qreal _progress = 0.0;
    bool _running = false;
    QString _errorString;
    QString _sourcePath;
    QString _outputPath;
    Operation _operation = Operation::None;
    std::shared_ptr<std::atomic_bool> _cancelRequested;
};