15 #if defined (THREADING_DEBUG)
16 #include <MobileDgn/Utils/BeDbgHelp.h>
18 #define ASYNC_TASK_ADD_DEBUG_INFO(task, callerFrame) { task->SetStackInfo(BeDbgHelp::GetStackInfoAt(callerFrame)); }
21 #define ASYNC_TASK_ADD_DEBUG_INFO(task, callerFrame)
26 struct ITaskScheduler;
37 virtual void _OnAsyncTaskCompleted (std::shared_ptr<struct AsyncTask> task) = 0;
61 bset<std::weak_ptr<OnAsyncTaskCompletedListener>, std::owner_less<std::weak_ptr<OnAsyncTaskCompletedListener>>> m_onCompletedListeners;
66 bvector <bpair<std::shared_ptr<AsyncTask>, std::shared_ptr<ITaskScheduler>>> m_thenTasks;
67 bset<std::shared_ptr<AsyncTask>> m_subTasks;
68 bset<std::shared_ptr<AsyncTask>> m_parentTasks;
72 #if defined (THREADING_DEBUG)
73 BeDbgHelp::StackInfo m_stackInfo;
77 void SetPriority (Priority priority);
82 void AddSubTaskNoLock (std::shared_ptr<AsyncTask> task);
83 void AddParentTaskNoLock (std::shared_ptr<AsyncTask> task);
85 void ProcessTaskCompletion ();
86 void CleanUpTask (std::shared_ptr<AsyncTask> task, bset<std::shared_ptr<AsyncTask>>& tasksToCleanUp);
88 void NotifyOnCompletedListeners ();
93 BENTLEYDLL_EXPORT void RegisterOnCompletedListener (std::shared_ptr<OnAsyncTaskCompletedListener> listener);
94 BENTLEYDLL_EXPORT void UnregisterOnCompletedListener (std::shared_ptr<OnAsyncTaskCompletedListener> listener);
96 BENTLEYDLL_EXPORT void AddThenTask (std::shared_ptr<AsyncTask> task, std::shared_ptr<ITaskScheduler> scheduler =
nullptr);
102 BENTLEYDLL_EXPORT static void PushTaskToDefaultSheduler(std::shared_ptr<AsyncTask> task);
114 static std::shared_ptr<PackagedAsyncTask<void>>
WhenAll(C tasks)
116 auto whenAll = std::make_shared<PackagedAsyncTask<void>>([]{});
117 for (
auto task : tasks)
118 whenAll->AddSubTask(task);
122 for (
auto task : tasks)
123 if (task->IsCompleted())
124 whenAll->RemoveSubTask(task);
126 PushTaskToDefaultSheduler(whenAll);
146 #if defined (THREADING_DEBUG)
147 void SetStackInfo(
const BeDbgHelp::StackInfo& stackInfo)
149 m_stackInfo = stackInfo;
163 std::function<T (void)> m_taskCallback;
175 m_result = m_taskCallback ();
181 Wait ();
return m_result;
186 std::shared_ptr<PackagedThenAsyncTask<R, T>>
Then (
const std::function<R (T&)>& taskCallback)
188 auto task = std::make_shared<PackagedThenAsyncTask<R, T>> (taskCallback, std::shared_ptr <T> (shared_from_this (), &m_result));
196 std::shared_ptr<PackagedThenAsyncTask<R, T>>
Then (std::shared_ptr<ITaskScheduler> scheduler,
const std::function<R (T&)>& taskCallback)
198 auto task = std::make_shared<PackagedThenAsyncTask<R, T>> (taskCallback, std::shared_ptr <T> (shared_from_this (), &m_result));
200 AddThenTask (task, scheduler);
205 std::shared_ptr<PackagedThenAsyncTask<void, T>>
Then (std::shared_ptr<ITaskScheduler> scheduler,
const std::function<
void (T&)>& taskCallback)
207 auto task = std::make_shared<PackagedThenAsyncTask<void, T>> (taskCallback, std::shared_ptr <T> (shared_from_this (), &m_result));
209 AddThenTask (task, scheduler);
214 std::shared_ptr<PackagedThenAsyncTask<void, T>>
Then (
const std::function<
void (T&)>& taskCallback)
216 auto task = std::make_shared<PackagedThenAsyncTask<void, T>> (taskCallback, std::shared_ptr <T> (shared_from_this (), &m_result));
244 std::shared_ptr<PackagedAsyncTask<R>>
Then (
const std::function<R (
void)>& taskCallback)
246 auto task = std::make_shared<PackagedAsyncTask<R>> (taskCallback);
254 std::shared_ptr<PackagedAsyncTask<R>>
Then (std::shared_ptr<ITaskScheduler> scheduler,
const std::function<R (
void)>& taskCallback)
256 auto task = std::make_shared<PackagedAsyncTask<R>> (taskCallback);
258 AddThenTask (task, scheduler);
263 std::shared_ptr<PackagedAsyncTask<void>>
Then (
const std::function<
void (
void)>& taskCallback)
265 auto task = std::make_shared<PackagedAsyncTask<void>> (taskCallback);
272 std::shared_ptr<PackagedAsyncTask<void>>
Then (std::shared_ptr<ITaskScheduler> scheduler,
const std::function<
void (
void)>& taskCallback)
274 auto task = std::make_shared<PackagedAsyncTask<void>> (taskCallback);
276 AddThenTask (task, scheduler);
287 template <
class T,
class P>
291 std::shared_ptr<P> m_parentResult;
293 std::function<T (P&)> m_taskCallback;
298 m_taskCallback (taskCallback),
299 m_parentResult (parentResult)
305 this->m_result = this->m_taskCallback (*m_parentResult.get ());
316 std::shared_ptr<P> m_parentResult;
318 std::function<void (P&)> m_taskCallback;
323 m_taskCallback (taskCallback),
324 m_parentResult (parentResult)
330 this->m_taskCallback (*m_parentResult.get ());
337 template <
typename T>
341 auto task = std::make_shared<PackagedAsyncTask<T>> ([=]
#define BENTLEYDLL_EXPORT
Definition: Bentley.h:249
A synchronization primitive that can be used to block a thread, or multiple threads at the same time...
Definition: BeThread.h:132
Definition: AsyncTask.h:33
Definition: AsyncTask.h:28
PackagedAsyncTask(const std::function< T(void)> &taskCallback)
Definition: AsyncTask.h:169
Definition: AsyncTask.h:43
The default file attribute.
Together with the BeCriticalSection.h file provides Bentley specific thread handling functions (Bentl...
#define ASYNC_TASK_ADD_DEBUG_INFO(task, callerFrame)
Definition: AsyncTask.h:21
Provides Bentley specific set implementation (Bentley/bset.h).
A BeMutex ownership wrapper.
Definition: BeThread.h:82
std::shared_ptr< PackagedThenAsyncTask< void, T > > Then(const std::function< void(T &)> &taskCallback)
Execute new task with callback code in default thread after this task is finished.
Definition: AsyncTask.h:214
std::shared_ptr< PackagedAsyncTask< R > > Then(std::shared_ptr< ITaskScheduler > scheduler, const std::function< R(void)> &taskCallback)
Execute new task with callback code in sheduler/thread/pool after this task is finished.
Definition: AsyncTask.h:254
T m_result
Definition: AsyncTask.h:166
virtual void _OnExecute()
Definition: AsyncTask.h:303
std::shared_ptr< PackagedThenAsyncTask< R, T > > Then(std::shared_ptr< ITaskScheduler > scheduler, const std::function< R(T &)> &taskCallback)
Execute new task with callback code in sheduler/thread/pool after this task is finished.
Definition: AsyncTask.h:196
virtual void _OnExecute()
Definition: AsyncTask.h:328
PackagedAsyncTask(const std::function< void(void)> &taskCallback)
Definition: AsyncTask.h:233
std::shared_ptr< PackagedAsyncTask< R > > Then(const std::function< R(void)> &taskCallback)
Execute new task with callback code in default thread after this task is finished.
Definition: AsyncTask.h:244
std::shared_ptr< PackagedAsyncTask< void > > Then(const std::function< void(void)> &taskCallback)
Execute new task with callback code in default thread after this task is finished.
Definition: AsyncTask.h:263
#define BEGIN_BENTLEY_TASKS_NAMESPACE
Definition: Tasks.h:13
AsyncTaskPtr< void > CreateCompletedAsyncTask()
Create task that is flagged as completed without executing it.
std::function< void(void)> m_taskCallback
Definition: AsyncTask.h:230
Definition: AsyncTaskRunner.h:20
Definition: AsyncTask.h:157
Priority
Definition: AsyncTask.h:49
std::shared_ptr< PackagedThenAsyncTask< R, T > > Then(const std::function< R(T &)> &taskCallback)
Execute new task with callback code in default thread after this task is finished.
Definition: AsyncTask.h:186
virtual void _OnExecute()
Definition: AsyncTask.h:173
A synchronization primitive that can be used to protect shared data from being simultaneously accesse...
Definition: BeThread.h:57
std::shared_ptr< PackagedThenAsyncTask< void, T > > Then(std::shared_ptr< ITaskScheduler > scheduler, const std::function< void(T &)> &taskCallback)
Execute new task with callback code in sheduler/thread/pool after this task is finished.
Definition: AsyncTask.h:205
virtual void _OnExecute()
Definition: AsyncTask.h:237
PackagedThenAsyncTask(const std::function< T(P &)> &taskCallback, std::shared_ptr< P > parentResult)
Definition: AsyncTask.h:296
std::shared_ptr< PackagedAsyncTask< T >> AsyncTaskPtr
Definition: AsyncTask.h:282
#define END_BENTLEY_TASKS_NAMESPACE
Definition: Tasks.h:14
T & GetResult()
Blocks until result is available. See Wait()
Definition: AsyncTask.h:179
Definition: TaskScheduler.h:77
std::shared_ptr< PackagedAsyncTask< void > > Then(std::shared_ptr< ITaskScheduler > scheduler, const std::function< void(void)> &taskCallback)
Execute new task with callback code in sheduler/thread/pool after this task is finished.
Definition: AsyncTask.h:272
#define EXPORT_VTABLE_ATTRIBUTE
Definition: Bentley.h:67
static std::shared_ptr< PackagedAsyncTask< void > > WhenAll(C tasks)
Create task that will complete once all task in container are completed.
Definition: AsyncTask.h:114
PackagedThenAsyncTask(const std::function< void(P &)> &taskCallback, std::shared_ptr< P > parentResult)
Definition: AsyncTask.h:321