blob: 3d6e7f1cc1bf60e8c736412ffd227a96459db9ff (
plain) (
blame)
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
|
//
// TaskManager.h
//
// Library: Foundation
// Package: Tasks
// Module: Tasks
//
// Definition of the TaskManager class.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_TaskManager_INCLUDED
#define Foundation_TaskManager_INCLUDED
#include "Poco/Foundation.h"
#include "Poco/Mutex.h"
#include "Poco/Task.h"
#include "Poco/AutoPtr.h"
#include "Poco/NotificationCenter.h"
#include "Poco/Timestamp.h"
#include <list>
namespace Poco {
class Notification;
class ThreadPool;
class Exception;
class Foundation_API TaskManager
/// The TaskManager manages a collection of tasks
/// and monitors their lifetime.
///
/// A TaskManager has a built-in NotificationCenter that
/// is used to send out notifications on task progress
/// and task states. See the TaskNotification class and its
/// subclasses for the various events that result in a notification.
/// To keep the number of notifications small, a TaskProgressNotification
/// will only be sent out once in 100 milliseconds.
{
public:
typedef AutoPtr<Task> TaskPtr;
typedef std::list<TaskPtr> TaskList;
TaskManager();
/// Creates the TaskManager, using the
/// default ThreadPool.
TaskManager(ThreadPool& pool);
/// Creates the TaskManager, using the
/// given ThreadPool.
~TaskManager();
/// Destroys the TaskManager.
void start(Task* pTask);
/// Starts the given task in a thread obtained
/// from the thread pool.
///
/// The TaskManager takes ownership of the Task object
/// and deletes it when it it finished.
void cancelAll();
/// Requests cancellation of all tasks.
void joinAll();
/// Waits for the completion of all the threads
/// in the TaskManager's thread pool.
///
/// Note: joinAll() will wait for ALL tasks in the
/// TaskManager's ThreadPool to complete. If the
/// ThreadPool has threads created by other
/// facilities, these threads must also complete
/// before joinAll() can return.
TaskList taskList() const;
/// Returns a copy of the internal task list.
int count() const;
/// Returns the number of tasks in the internal task list.
void addObserver(const AbstractObserver& observer);
/// Registers an observer with the NotificationCenter.
/// Usage:
/// Observer<MyClass, MyNotification> obs(*this, &MyClass::handleNotification);
/// notificationCenter.addObserver(obs);
void removeObserver(const AbstractObserver& observer);
/// Unregisters an observer with the NotificationCenter.
static const int MIN_PROGRESS_NOTIFICATION_INTERVAL;
protected:
void postNotification(const Notification::Ptr& pNf);
/// Posts a notification to the task manager's
/// notification center.
void taskStarted(Task* pTask);
void taskProgress(Task* pTask, float progress);
void taskCancelled(Task* pTask);
void taskFinished(Task* pTask);
void taskFailed(Task* pTask, const Exception& exc);
private:
ThreadPool& _threadPool;
TaskList _taskList;
Timestamp _lastProgressNotification;
NotificationCenter _nc;
mutable FastMutex _mutex;
friend class Task;
};
//
// inlines
//
inline int TaskManager::count() const
{
FastMutex::ScopedLock lock(_mutex);
return (int) _taskList.size();
}
} // namespace Poco
#endif // Foundation_TaskManager_INCLUDED
|
