1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
/***
Olive - Non-Linear Video Editor
Copyright (C) 2019 Olive Team
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 3 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, see <http://www.gnu.org/licenses/>.
***/
#ifndef TASKMANAGER_H
#define TASKMANAGER_H
#include <QtConcurrent/QtConcurrent>
#include <QVector>
#include <QUndoCommand>
#include "task/task.h"
OLIVE_NAMESPACE_ENTER
/**
* @brief An object that manages background Task objects, handling their start and end
*
* TaskManager handles the life of a Task object. After a new Task is created, it should be sent to TaskManager through
* AddTask(). TaskManager will take ownership of the task and add it to a queue until it system resources are available
* for it to run. Currently, TaskManager will run no more Tasks than there are threads on the system (one task per
* thread). As Tasks finished, TaskManager will start the next in the queue.
*/
class TaskManager : public QObject
{
Q_OBJECT
public:
/**
* @brief TaskManager Constructor
*/
TaskManager();
/**
* @brief TaskManager Destructor
*
* Ensures all Tasks are deleted
*/
virtual ~TaskManager();
static void CreateInstance();
static void DestroyInstance();
static TaskManager* instance();
int GetTaskCount() const;
Task* GetFirstTask() const;
void CancelTaskAndWait(Task* t);
public slots:
/**
* @brief Add a new Task
*
* Adds a new Task to the queue. If there are available threads to run it, it'll also run immediately. Otherwise,
* it'll be placed into the queue and run when resources are available.
*
* NOTE: This function is NOT thread-safe and is currently intended to only be used from the main/GUI thread.
*
* NOTE: A Task object should only be added once. Adding the same Task object more than once will result in undefined
* behavior.
*
* @param t
*
* The task to add and run. TaskManager takes ownership of this Task and will be responsible for freeing it.
*/
void AddTask(Task *t);
void CancelTask(Task* t);
signals:
/**
* @brief Signal emitted when a Task is added by AddTask()
*
* @param t
*
* Task that was added
*/
void TaskAdded(Task* t);
/**
* @brief Signal emitted when any change to the running task list has been made
*/
void TaskListChanged();
/**
* @brief Signal emitted when a task is deleted
*/
void TaskRemoved(Task* t);
/**
* @brief Signal emitted when a task fails
*/
void TaskFailed(Task* t);
private:
/**
* @brief Internal task array
*/
QHash<QFutureWatcher<bool>*, Task*> tasks_;
/**
* @brief Internal list of failed tasks
*/
std::list<Task*> failed_tasks_;
/**
* @brief Task thread pool
*/
QThreadPool thread_pool_;
/**
* @brief TaskManager singleton instance
*/
static TaskManager* instance_;
private slots:
void TaskFinished();
};
OLIVE_NAMESPACE_EXIT
#endif // TASKMANAGER_H
|
