forked from taskflow/taskflow
-
Notifications
You must be signed in to change notification settings - Fork 1
Expand file tree
/
Copy pathtask.hpp
More file actions
296 lines (225 loc) · 5.79 KB
/
task.hpp
File metadata and controls
296 lines (225 loc) · 5.79 KB
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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
#pragma once
#include "graph.hpp"
namespace tf {
/**
@class Task
@brief Handle to modify and access a task.
A Task is a wrapper of a node in a dependency graph.
It provides a set of methods for users to access and modify the attributes of
the task node,
preventing direct access to the internal data storage.
*/
class Task {
friend class FlowBuilder;
template <template<typename...> typename E>
friend class BasicTaskflow;
public:
/**
@brief constructs an empty task
*/
Task() = default;
/**
@brief constructs the task with the copy of the other task
*/
Task(const Task& other);
/**
@brief constructs the task with the content of the other task using move semantics
After the move, other is guaranteed to be empty
*/
Task(Task&& other);
/**
@brief replaces the contents with a copy of the other task
*/
Task& operator = (const Task&);
/**
@brief queries the name of the task
*/
const std::string& name() const;
/**
@brief queries the number of successors of the task
*/
size_t num_successors() const;
/**
@brief queries the number of predecessors of the task
*/
size_t num_dependents() const;
/**
@brief assigns a name to the task
@param name a @std_string acceptable string
@return @c *this
*/
Task& name(const std::string& name);
/**
@brief assigns a new callable object to the task
@tparam C callable object type
@param callable a callable object acceptable to @std_function
@return @c *this
*/
template <typename C>
Task& work(C&& callable);
/**
@brief adds precedence links from this to other tasks
@tparam Ts... parameter pack
@param tasks... one or multiple tasks
@return @c *this
*/
template <typename... Ts>
Task& precede(Ts&&... tasks);
/**
@brief adds precedence links from this to others
@param tasks a vector of tasks to precede
@return @c *this
*/
Task& precede(std::vector<Task>& tasks);
/**
@brief adds precedence links from this to others
@param tasks an initializer list of tasks to precede
@return @c *this
*/
Task& precede(std::initializer_list<Task> tasks);
/**
@brief adds precedence links from other tasks to this
@tparam Ts parameter pack
@param tasks... one or multiple tasks
@return @c *this
*/
template <typename... Ts>
Task& gather(Ts&&... tasks);
/**
@brief adds precedence links from other tasks to this
@param tasks a vector of tasks
@return @c *this
*/
Task& gather(std::vector<Task>& tasks);
/**
@brief adds precedence links from other tasks to this
@param tasks an initializer list of tasks
@return @c *this
*/
Task& gather(std::initializer_list<Task> tasks);
//template <typename... Bs>
//Task& broadcast(Bs&&...);
//
//Task& broadcast(std::vector<Task>&);
//Task& broadcast(std::initializer_list<Task>);
private:
Task(Node&);
Node* _node {nullptr};
//template <typename S>
//void _broadcast(S&);
template <typename S>
void _gather(S&);
template <typename S>
void _precede(S&);
};
// Constructor
inline Task::Task(Node& t) : _node {&t} {
}
// Constructor
inline Task::Task(const Task& rhs) : _node {rhs._node} {
}
//// Function: broadcast
//template <typename... Bs>
//Task& Task::broadcast(Bs&&... tgts) {
// (_node->precede(*(tgts._node)), ...);
// return *this;
//}
//
//// Procedure: _broadcast
//template <typename S>
//inline void Task::_broadcast(S& tgts) {
// for(auto& to : tgts) {
// _node->precede(*(to._node));
// }
//}
//
//// Function: broadcast
//inline Task& Task::broadcast(std::vector<Task>& tgts) {
// _broadcast(tgts);
// return *this;
//}
//
//// Function: broadcast
//inline Task& Task::broadcast(std::initializer_list<Task> tgts) {
// _broadcast(tgts);
// return *this;
//}
// Function: precede
template <typename... Ts>
Task& Task::precede(Ts&&... tgts) {
(_node->precede(*(tgts._node)), ...);
return *this;
}
// Function: precede
inline Task& Task::precede(std::vector<Task>& tgts) {
_precede(tgts);
return *this;
}
// Function: precede
inline Task& Task::precede(std::initializer_list<Task> tgts) {
_precede(tgts);
return *this;
}
// Function: gather
template <typename... Bs>
Task& Task::gather(Bs&&... tgts) {
(tgts._node->precede(*_node), ...);
return *this;
}
// Procedure: _gather
template <typename S>
void Task::_gather(S& tgts) {
for(auto& from : tgts) {
from._node->precede(*_node);
}
}
// Procedure: _precede
template <typename S>
void Task::_precede(S& tgts) {
for(auto& to : tgts) {
_node->precede(*(to._node));
}
}
// Function: gather
inline Task& Task::gather(std::vector<Task>& tgts) {
_gather(tgts);
return *this;
}
// Function: gather
inline Task& Task::gather(std::initializer_list<Task> tgts) {
_gather(tgts);
return *this;
}
// Operator =
inline Task& Task::operator = (const Task& rhs) {
_node = rhs._node;
return *this;
}
// Constructor
inline Task::Task(Task&& rhs) : _node{rhs._node} {
rhs._node = nullptr;
}
// Function: work
template <typename C>
inline Task& Task::work(C&& c) {
_node->_work = std::forward<C>(c);
return *this;
}
// Function: name
inline Task& Task::name(const std::string& name) {
_node->_name = name;
return *this;
}
// Function: name
inline const std::string& Task::name() const {
return _node->_name;
}
// Function: num_dependents
inline size_t Task::num_dependents() const {
return _node->_dependents.load(std::memory_order_relaxed);
}
// Function: num_successors
inline size_t Task::num_successors() const {
return _node->_successors.size();
}
}; // end of namespace tf. ---------------------------------------------------