qgstaskmanager.h

Go to the documentation of this file.

/***************************************************************************
                          qgstaskmanager.h
                          ----------------
    begin                : April 2016
    copyright            : (C) 2016 by Nyall Dawson
    email                : nyall dot dawson at gmail dot com
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 ***************************************************************************/
 
#ifndef QGSTASKMANAGER_H
#define QGSTASKMANAGER_H
 
#include <QObject>
#include "qgis_sip.h"
#include <QMap>
#include <QFuture>
#include <QReadWriteLock>
#include <QSemaphore>
#include <QElapsedTimer>
 
#include "qgis_core.h"
#include "qgsmaplayer.h"
 
class QgsTask;
class QgsTaskRunnableWrapper;
 
typedef QList< QgsTask * > QgsTaskList;
 
class CORE_EXPORT QgsTask : public QObject
{
    Q_OBJECT
 
  public:
 
    enum TaskStatus
    {
      Queued, 
      OnHold, 
      Running, 
      Complete, 
      Terminated, 
    };
    Q_ENUM( TaskStatus )
 
    
    enum Flag SIP_ENUM_BASETYPE( IntFlag )
    {
      CanCancel = 1 << 1, 
      CancelWithoutPrompt = 1 << 2, 
      Hidden = 1 << 3, 
      Silent = 1 << 4, 
      AllFlags = CanCancel, 
    };
    Q_DECLARE_FLAGS( Flags, Flag )
 
    
    QgsTask( const QString &description = QString(), QgsTask::Flags flags = AllFlags );
 
    ~QgsTask() override;
 
    Flags flags() const { return mFlags; }
 
    void setDescription( const QString &description );
 
    bool canCancel() const { return mFlags & CanCancel; }
 
    bool isActive() const { return mOverallStatus == Running; }
 
    TaskStatus status() const { return mOverallStatus; }
 
    QString description() const { return mDescription; }
 
    double progress() const { return mTotalProgress; }
 
    qint64 elapsedTime() const;
 
    virtual void cancel();
 
    void hold();
 
    void unhold();
 
    enum SubTaskDependency
    {
      SubTaskIndependent = 0, 
      ParentDependsOnSubTask, 
    };
 
    void addSubTask( QgsTask *subTask SIP_TRANSFER, const QgsTaskList &dependencies = QgsTaskList(),
                     SubTaskDependency subTaskDependency = SubTaskIndependent );
 
    void setDependentLayers( const QList<QgsMapLayer *> &dependentLayers );
 
    QList< QgsMapLayer * > dependentLayers() const;
 
    bool waitForFinished( int timeout = 30000 );
 
  signals:
 
    void progressChanged( double progress );
 
    void statusChanged( int status );
 
    void begun();
 
    void taskCompleted();
 
    void taskTerminated();
 
  protected:
 
    virtual bool run() = 0;
 
    virtual void finished( bool result ) { Q_UNUSED( result ) }
 
    bool isCanceled() const;
 
  protected slots:
 
    void setProgress( double progress );
 
  private slots:
    void subTaskStatusChanged( int status );
 
  private:
 
    Flags mFlags;
    QString mDescription;
    TaskStatus mStatus = Queued;
    TaskStatus mOverallStatus = Queued;
 
    QMutex mNotFinishedMutex;
 
    QSemaphore mNotStartedMutex;
 
    double mProgress = 0.0;
    double mTotalProgress = 0.0;
    bool mShouldTerminate = false;
    mutable QMutex mShouldTerminateMutex;
    int mStartCount = 0;
 
    struct SubTask
    {
      SubTask( QgsTask *task, const QgsTaskList &dependencies, SubTaskDependency dependency )
        : task( task )
        , dependencies( dependencies )
        , dependency( dependency )
      {}
      QgsTask *task = nullptr;
      QgsTaskList dependencies;
      SubTaskDependency dependency;
    };
    QList< SubTask > mSubTasks;
 
    QgsWeakMapLayerPointerList mDependentLayers;
 
    QElapsedTimer mElapsedTime;
 
 
    void start();
 
    void completed();
 
    void terminated();
 
 
    void processSubTasksForHold();
 
    friend class QgsTaskManager;
    friend class QgsTaskWithSerialSubTasks;
    friend class QgsTaskRunnableWrapper;
    friend class TestQgsTaskManager;
 
  private slots:
 
    void processSubTasksForCompletion();
 
    void processSubTasksForTermination();
 
};
 
 
Q_DECLARE_OPERATORS_FOR_FLAGS( QgsTask::Flags )
 
 
class CORE_EXPORT QgsTaskManager : public QObject
{
    Q_OBJECT
 
  public:
 
    QgsTaskManager( QObject *parent SIP_TRANSFERTHIS = nullptr );
 
    ~QgsTaskManager() override;
 
    struct TaskDefinition
    {
 
      explicit TaskDefinition( QgsTask *task, const QgsTaskList &dependentTasks = QgsTaskList() )
        : task( task )
        , dependentTasks( dependentTasks )
      {}
 
      QgsTask *task = nullptr;
 
      QgsTaskList dependentTasks;
 
    };
 
    QThreadPool *threadPool();
 
    long addTask( QgsTask *task SIP_TRANSFER, int priority = 0 );
 
    long addTask( const TaskDefinition &task SIP_TRANSFER, int priority = 0 );
 
    QgsTask *task( long id ) const;
 
    QList<QgsTask *> tasks() const;
 
    int count() const;
 
    long taskId( QgsTask *task ) const;
 
    void cancelAll();
 
    bool dependenciesSatisfied( long taskId ) const;
 
    QSet< long > dependencies( long taskId ) const SIP_SKIP;
 
    QList< QgsMapLayer * > dependentLayers( long taskId ) const;
 
    QList< QgsTask * > tasksDependentOnLayer( QgsMapLayer *layer ) const;
 
    QList< QgsTask * > activeTasks() const;
 
    int countActiveTasks( bool includeHidden = true ) const;
 
  public slots:
 
    void triggerTask( QgsTask *task );
 
  signals:
 
    void progressChanged( long taskId, double progress );
 
    void finalTaskProgressChanged( double progress );
 
    void statusChanged( long taskId, int status );
 
    void taskAdded( long taskId );
 
    void taskAboutToBeDeleted( long taskId );
 
    void allTasksFinished();
 
    void countActiveTasksChanged( int count );
 
    void taskTriggered( QgsTask *task );
 
  private slots:
 
    void taskProgressChanged( double progress );
    void taskStatusChanged( int status );
    void layersWillBeRemoved( const QList<QgsMapLayer *> &layers );
 
  private:
 
    struct TaskInfo
    {
      TaskInfo( QgsTask *task = nullptr, int priority = 0 );
      void createRunnable();
      QgsTask *task = nullptr;
      QAtomicInt added;
      int priority;
      QgsTaskRunnableWrapper *runnable = nullptr;
    };
 
    QThreadPool *mThreadPool = nullptr;
 
    bool mInitialized = false;
 
    mutable QRecursiveMutex *mTaskMutex;
 
    QMap< long, TaskInfo > mTasks;
    QMap< QgsTask *, long> mMapTaskPtrToId;
    QMap< long, QgsTaskList > mTaskDependencies;
    QMap< long, QgsWeakMapLayerPointerList > mLayerDependencies;
 
    long mNextTaskId = 1;
 
    QSet< QgsTask * > mActiveTasks;
    QSet< QgsTask * > mParentTasks;
    QSet< QgsTask * > mSubTasks;
 
    QSet< QgsTask * > mPendingDeletion;
 
    long addTaskPrivate( QgsTask *task,
                         QgsTaskList dependencies,
                         bool isSubTask,
                         int priority );
 
    bool cleanupAndDeleteTask( QgsTask *task );
 
    void processQueue();
 
    void cancelDependentTasks( long taskId );
 
    bool resolveDependencies( long taskId, QSet< long > &results ) const;
 
    bool hasCircularDependencies( long taskId ) const;
 
    friend class TestQgsTaskManager;
};
 
class CORE_EXPORT QgsTaskWithSerialSubTasks : public QgsTask
{
    Q_OBJECT
 
  public:
    QgsTaskWithSerialSubTasks( const QString &desc = QString() ) : QgsTask( desc ) {}
 
    ~QgsTaskWithSerialSubTasks() override;
 
    void addSubTask( QgsTask *subTask SIP_TRANSFER );
 
    void cancel() override;
 
  protected:
 
    QList< QgsTask *> mSubTasksSerial;
 
    bool run() override;
};
 
#endif //QGSTASKMANAGER_H