8.9

1 files changed, 143 insertions, 150 deletions

diff --git a/wx+/async_task.h b/wx+/async_task.h
index 7ac03949..36d9068e 100644..100755
--- a/wx+/async_task.h
+++ b/wx+/async_task.h
@@ -1,150 +1,143 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#ifndef ASYNC_TASK_H_839147839170432143214321
-#define ASYNC_TASK_H_839147839170432143214321
-
-#include <functional>
-#include <zen/thread.h>
-#include <zen/scope_guard.h>
-#include <zen/stl_tools.h>
-#include <wx/timer.h>
-
-
-namespace zen
-{
-/*
-Run a task in an async thread, but process result in GUI event loop
--------------------------------------------------------------------
-1. put AsyncGuiQueue instance inside a dialog:
-    AsyncGuiQueue guiQueue;
-
-2. schedule async task and synchronous continuation:
-    guiQueue.processAsync(evalAsync, evalOnGui);
-
-Alternative: use wxWidgets' inter-thread communication (wxEvtHandler::QueueEvent) https://wiki.wxwidgets.org/Inter-Thread_and_Inter-Process_communication
-        => don't bother, probably too many MT race conditions lurking around
-*/
-
-namespace impl
-{
-struct Task
-{
-    virtual ~Task() {}
-    virtual bool resultReady   () const = 0;
-    virtual void evaluateResult()       = 0;
-};
-
-
-template <class ResultType, class Fun>
-class ConcreteTask : public Task
-{
-public:
-    template <class Fun2>
-    ConcreteTask(std::future<ResultType>&& asyncResult, Fun2&& evalOnGui) : asyncResult_(std::move(asyncResult)), evalOnGui_(std::forward<Fun2>(evalOnGui)) {}
-
-    bool resultReady   () const override { return isReady(asyncResult_); }
-    void evaluateResult()       override
-    {
-#ifndef NDEBUG
-        assert(resultReady() && !resultEvaluated_);
-        resultEvaluated_ = true;
-#endif
-        evalResult(IsSameType<ResultType, void>());
-    }
-
-private:
-    void evalResult(FalseType /*void result type*/) { evalOnGui_(asyncResult_.get()); }
-    void evalResult(TrueType  /*void result type*/) { asyncResult_.get(); evalOnGui_(); }
-
-    std::future<ResultType> asyncResult_;
-    Fun evalOnGui_; //keep "evalOnGui" strictly separated from async thread: in particular do not copy in thread!
-#ifndef NDEBUG
-    bool resultEvaluated_ = false;
-#endif
-};
-
-
-class AsyncTasks
-{
-public:
-    AsyncTasks() {}
-
-    template <class Fun, class Fun2>
-    void add(Fun&& evalAsync, Fun2&& evalOnGui)
-    {
-        using ResultType = decltype(evalAsync());
-        tasks_.push_back(std::make_unique<ConcreteTask<ResultType, Fun2>>(zen::runAsync(std::forward<Fun>(evalAsync)), std::forward<Fun2>(evalOnGui)));
-    }
-    //equivalent to "evalOnGui(evalAsync())"
-    //  -> evalAsync: the usual thread-safety requirements apply!
-    //  -> evalOnGui: no thread-safety concerns, but must only reference variables with greater-equal lifetime than the AsyncTask instance!
-
-    void evalResults() //call from gui thread repreatedly
-    {
-        if (!inRecursion_) //prevent implicit recursion, e.g. if we're called from an idle event and spawn another one within the callback below
-        {
-            inRecursion_ = true;
-            ZEN_ON_SCOPE_EXIT(inRecursion_ = false);
-
-            std::vector<std::unique_ptr<Task>> readyTasks; //Reentrancy; access to AsyncTasks::add is not protected! => evaluate outside erase_if
-
-            erase_if(tasks_, [&](std::unique_ptr<Task>& task)
-            {
-                if (task->resultReady())
-                {
-                    readyTasks.push_back(std::move(task));
-                    return true;
-                }
-                return false;
-            });
-
-            for (auto& task : readyTasks)
-                task->evaluateResult();
-        }
-    }
-
-    bool empty() const { return tasks_.empty(); }
-
-private:
-    AsyncTasks           (const AsyncTasks&) = delete;
-    AsyncTasks& operator=(const AsyncTasks&) = delete;
-
-    bool inRecursion_ = false;
-    std::vector<std::unique_ptr<Task>> tasks_;
-};
-}
-
-
-class AsyncGuiQueue : private wxEvtHandler
-{
-public:
-    AsyncGuiQueue() { timer_.Connect(wxEVT_TIMER, wxEventHandler(AsyncGuiQueue::onTimerEvent), nullptr, this); }
-
-    template <class Fun, class Fun2>
-    void processAsync(Fun&& evalAsync, Fun2&& evalOnGui)
-    {
-        asyncTasks_.add(std::forward<Fun >(evalAsync),
-                        std::forward<Fun2>(evalOnGui));
-        if (!timer_.IsRunning())
-            timer_.Start(50 /*unit: [ms]*/);
-    }
-
-private:
-    void onTimerEvent(wxEvent& event) //schedule and run long-running tasks asynchronously
-    {
-        asyncTasks_.evalResults(); //process results on GUI queue
-        if (asyncTasks_.empty())
-            timer_.Stop();
-    }
-
-    impl::AsyncTasks asyncTasks_;
-    wxTimer timer_; //don't use wxWidgets' idle handling => repeated idle requests/consumption hogs 100% cpu!
-};
-
-}
-
-#endif //ASYNC_TASK_H_839147839170432143214321
+// *****************************************************************************

+// * This file is part of the FreeFileSync project. It is distributed under    *

+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *

+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *

+// *****************************************************************************

+

+#ifndef ASYNC_TASK_H_839147839170432143214321

+#define ASYNC_TASK_H_839147839170432143214321

+

+#include <functional>

+#include <zen/thread.h>

+#include <zen/scope_guard.h>

+#include <zen/stl_tools.h>

+#include <wx/timer.h>

+

+

+namespace zen

+{

+/*

+Run a task in an async thread, but process result in GUI event loop

+-------------------------------------------------------------------

+1. put AsyncGuiQueue instance inside a dialog:

+    AsyncGuiQueue guiQueue;

+

+2. schedule async task and synchronous continuation:

+    guiQueue.processAsync(evalAsync, evalOnGui);

+

+Alternative: use wxWidgets' inter-thread communication (wxEvtHandler::QueueEvent) https://wiki.wxwidgets.org/Inter-Thread_and_Inter-Process_communication

+        => don't bother, probably too many MT race conditions lurking around

+*/

+

+namespace impl

+{

+struct Task

+{

+    virtual ~Task() {}

+    virtual bool resultReady   () const = 0;

+    virtual void evaluateResult()       = 0;

+};

+

+

+template <class ResultType, class Fun>

+class ConcreteTask : public Task

+{

+public:

+    template <class Fun2>

+    ConcreteTask(std::future<ResultType>&& asyncResult, Fun2&& evalOnGui) : asyncResult_(std::move(asyncResult)), evalOnGui_(std::forward<Fun2>(evalOnGui)) {}

+

+    bool resultReady   () const override { return isReady(asyncResult_); }

+    void evaluateResult()       override

+    {

+        evalResult(IsSameType<ResultType, void>());

+    }

+

+private:

+    void evalResult(FalseType /*void result type*/) { evalOnGui_(asyncResult_.get()); }

+    void evalResult(TrueType  /*void result type*/) { asyncResult_.get(); evalOnGui_(); }

+

+    std::future<ResultType> asyncResult_;

+    Fun evalOnGui_; //keep "evalOnGui" strictly separated from async thread: in particular do not copy in thread!

+};

+

+

+class AsyncTasks

+{

+public:

+    AsyncTasks() {}

+

+    template <class Fun, class Fun2>

+    void add(Fun&& evalAsync, Fun2&& evalOnGui)

+    {

+        using ResultType = decltype(evalAsync());

+        tasks_.push_back(std::make_unique<ConcreteTask<ResultType, Fun2>>(zen::runAsync(std::forward<Fun>(evalAsync)), std::forward<Fun2>(evalOnGui)));

+    }

+    //equivalent to "evalOnGui(evalAsync())"

+    //  -> evalAsync: the usual thread-safety requirements apply!

+    //  -> evalOnGui: no thread-safety concerns, but must only reference variables with greater-equal lifetime than the AsyncTask instance!

+

+    void evalResults() //call from gui thread repreatedly

+    {

+        if (!inRecursion_) //prevent implicit recursion, e.g. if we're called from an idle event and spawn another one within the callback below

+        {

+            inRecursion_ = true;

+            ZEN_ON_SCOPE_EXIT(inRecursion_ = false);

+

+            std::vector<std::unique_ptr<Task>> readyTasks; //Reentrancy; access to AsyncTasks::add is not protected! => evaluate outside erase_if

+

+            erase_if(tasks_, [&](std::unique_ptr<Task>& task)

+            {

+                if (task->resultReady())

+                {

+                    readyTasks.push_back(std::move(task));

+                    return true;

+                }

+                return false;

+            });

+

+            for (auto& task : readyTasks)

+                task->evaluateResult();

+        }

+    }

+

+    bool empty() const { return tasks_.empty(); }

+

+private:

+    AsyncTasks           (const AsyncTasks&) = delete;

+    AsyncTasks& operator=(const AsyncTasks&) = delete;

+

+    bool inRecursion_ = false;

+    std::vector<std::unique_ptr<Task>> tasks_;

+};

+}

+

+

+class AsyncGuiQueue : private wxEvtHandler

+{

+public:

+    AsyncGuiQueue() { timer_.Connect(wxEVT_TIMER, wxEventHandler(AsyncGuiQueue::onTimerEvent), nullptr, this); }

+

+    template <class Fun, class Fun2>

+    void processAsync(Fun&& evalAsync, Fun2&& evalOnGui)

+    {

+        asyncTasks_.add(std::forward<Fun >(evalAsync),

+                        std::forward<Fun2>(evalOnGui));

+        if (!timer_.IsRunning())

+            timer_.Start(50 /*unit: [ms]*/);

+    }

+

+private:

+    void onTimerEvent(wxEvent& event) //schedule and run long-running tasks asynchronously

+    {

+        asyncTasks_.evalResults(); //process results on GUI queue

+        if (asyncTasks_.empty())

+            timer_.Stop();

+    }

+

+    impl::AsyncTasks asyncTasks_;

+    wxTimer timer_; //don't use wxWidgets' idle handling => repeated idle requests/consumption hogs 100% cpu!

+};

+

+}

+

+#endif //ASYNC_TASK_H_839147839170432143214321