From e4995e8d3a38dfd2ed64337e712ecf701af37454 Mon Sep 17 00:00:00 2001 From: John Firebaugh Date: Fri, 2 Sep 2016 16:52:25 -0700 Subject: [core] Extract WorkTaskImpl from run_loop.hpp --- include/mbgl/util/run_loop.hpp | 88 ++-------------------------------- include/mbgl/util/work_task.hpp | 8 ++++ include/mbgl/util/work_task_impl.hpp | 92 ++++++++++++++++++++++++++++++++++++ 3 files changed, 105 insertions(+), 83 deletions(-) create mode 100644 include/mbgl/util/work_task_impl.hpp (limited to 'include/mbgl') diff --git a/include/mbgl/util/run_loop.hpp b/include/mbgl/util/run_loop.hpp index 25f07c0312..af1053dfdc 100644 --- a/include/mbgl/util/run_loop.hpp +++ b/include/mbgl/util/run_loop.hpp @@ -47,11 +47,7 @@ public: // Invoke fn(args...) on this RunLoop. template void invoke(Fn&& fn, Args&&... args) { - auto tuple = std::make_tuple(std::move(args)...); - auto task = std::make_shared>( - std::move(fn), - std::move(tuple)); - + std::shared_ptr task = WorkTask::make(std::forward(fn), std::forward(args)...); push(task); } @@ -59,17 +55,8 @@ public: template std::unique_ptr invokeCancellable(Fn&& fn, Args&&... args) { - auto flag = std::make_shared>(); - *flag = false; - - auto tuple = std::make_tuple(std::move(args)...); - auto task = std::make_shared>( - std::move(fn), - std::move(tuple), - flag); - + std::shared_ptr task = WorkTask::make(std::forward(fn), std::forward(args)...); push(task); - return std::make_unique(task); } @@ -77,32 +64,8 @@ public: template std::unique_ptr invokeWithCallback(Fn&& fn, Cb&& callback, Args&&... args) { - auto flag = std::make_shared>(); - *flag = false; - - // Create a lambda L1 that invokes another lambda L2 on the current RunLoop R, that calls - // the callback C. Both lambdas check the flag before proceeding. L1 needs to check the flag - // because if the request was cancelled, then R might have been destroyed. L2 needs to check - // the flag because the request may have been cancelled after L2 was invoked but before it - // began executing. - auto after = [flag, current = RunLoop::Get(), callback1 = std::move(callback)] (auto&&... results1) { - if (!*flag) { - current->invoke([flag, callback2 = std::move(callback1)] (auto&&... results2) { - if (!*flag) { - callback2(std::move(results2)...); - } - }, std::move(results1)...); - } - }; - - auto tuple = std::make_tuple(std::move(args)..., after); - auto task = std::make_shared>( - std::move(fn), - std::move(tuple), - flag); - + std::shared_ptr task = WorkTask::makeWithCallback(std::forward(fn), std::forward(callback), std::forward(args)...); push(task); - return std::make_unique(task); } @@ -111,49 +74,6 @@ public: private: MBGL_STORE_THREAD(tid) - template - class Invoker : public WorkTask { - public: - Invoker(F&& f, P&& p, std::shared_ptr> canceled_ = nullptr) - : canceled(std::move(canceled_)), - func(std::move(f)), - params(std::move(p)) { - } - - void operator()() override { - // Lock the mutex while processing so that cancel() will block. - std::lock_guard lock(mutex); - if (!canceled || !*canceled) { - invoke(std::make_index_sequence::value>{}); - } - } - - // If the task has not yet begun, this will cancel it. - // If the task is in progress, this will block until it completed. (Currently - // necessary because of shared state, but should be removed.) It will also - // cancel the after callback. - // If the task has completed, but the after callback has not executed, this - // will cancel the after callback. - // If the task has completed and the after callback has executed, this will - // do nothing. - void cancel() override { - std::lock_guard lock(mutex); - *canceled = true; - } - - private: - template - void invoke(std::index_sequence) { - func(std::move(std::get(std::forward

(params)))...); - } - - std::recursive_mutex mutex; - std::shared_ptr> canceled; - - F func; - P params; - }; - using Queue = std::queue>; void push(std::shared_ptr); @@ -181,3 +101,5 @@ private: } // namespace util } // namespace mbgl + +#include diff --git a/include/mbgl/util/work_task.hpp b/include/mbgl/util/work_task.hpp index 43f4810b43..e9c2062d9c 100644 --- a/include/mbgl/util/work_task.hpp +++ b/include/mbgl/util/work_task.hpp @@ -2,6 +2,8 @@ #include +#include + namespace mbgl { // A movable type-erasing function wrapper. This allows to store arbitrary invokable @@ -13,6 +15,12 @@ public: virtual void operator()() = 0; virtual void cancel() = 0; + + template + static std::shared_ptr make(Fn&& fn, Args&&... args); + + template + static std::shared_ptr makeWithCallback(Fn&& fn, Cb&& callback, Args&&... args); }; } // namespace mbgl diff --git a/include/mbgl/util/work_task_impl.hpp b/include/mbgl/util/work_task_impl.hpp new file mode 100644 index 0000000000..2c016601bb --- /dev/null +++ b/include/mbgl/util/work_task_impl.hpp @@ -0,0 +1,92 @@ +#pragma once + +#include +#include + +#include + +namespace mbgl { + +template +class WorkTaskImpl : public WorkTask { +public: + WorkTaskImpl(F&& f, P&& p, std::shared_ptr> canceled_) + : canceled(std::move(canceled_)), + func(std::move(f)), + params(std::move(p)) { + } + + void operator()() override { + // Lock the mutex while processing so that cancel() will block. + std::lock_guard lock(mutex); + if (!*canceled) { + invoke(std::make_index_sequence::value>{}); + } + } + + // If the task has not yet begun, this will cancel it. + // If the task is in progress, this will block until it completed. (Currently + // necessary because of shared state, but should be removed.) It will also + // cancel the after callback. + // If the task has completed, but the after callback has not executed, this + // will cancel the after callback. + // If the task has completed and the after callback has executed, this will + // do nothing. + void cancel() override { + std::lock_guard lock(mutex); + *canceled = true; + } + +private: + template + void invoke(std::index_sequence) { + func(std::move(std::get(std::forward

(params)))...); + } + + std::recursive_mutex mutex; + std::shared_ptr> canceled; + + F func; + P params; +}; + +template +std::shared_ptr WorkTask::make(Fn&& fn, Args&&... args) { + auto flag = std::make_shared>(); + *flag = false; + + auto tuple = std::make_tuple(std::move(args)...); + return std::make_shared>( + std::move(fn), + std::move(tuple), + flag); +} + +template +std::shared_ptr WorkTask::makeWithCallback(Fn&& fn, Cb&& callback, Args&&... args) { + auto flag = std::make_shared>(); + *flag = false; + + // Create a lambda L1 that invokes another lambda L2 on the current RunLoop R, that calls + // the callback C. Both lambdas check the flag before proceeding. L1 needs to check the flag + // because if the request was cancelled, then R might have been destroyed. L2 needs to check + // the flag because the request may have been cancelled after L2 was invoked but before it + // began executing. + auto after = [flag, current = util::RunLoop::Get(), callback1 = std::move(callback)] (auto&&... results1) { + if (!*flag) { + current->invoke([flag, callback2 = std::move(callback1)] (auto&&... results2) { + if (!*flag) { + callback2(std::move(results2)...); + } + }, std::move(results1)...); + } + }; + + auto tuple = std::make_tuple(std::move(args)..., after); + return std::make_shared>( + std::move(fn), + std::move(tuple), + flag); +} + +} // namespace mbgl -- cgit v1.2.1