early-access version 1857

src/common/thread_worker.h

@@ -81,7 +81,7 @@ public:
         {
             std::unique_lock lock{queue_mutex};
             requests.emplace(std::move(work));
-            ++work_scherduled;
+            ++work_scheduled;
         }
         condition.notify_one();
     }
@@ -94,7 +94,7 @@ public:
         });
         std::unique_lock lock{queue_mutex};
         wait_condition.wait(lock, [this] {
-            return workers_stopped >= workers_queued || work_done >= work_scherduled;
+            return workers_stopped >= workers_queued || work_done >= work_scheduled;
         });
     }
 
@@ -103,7 +103,7 @@ private:
     std::mutex queue_mutex;
     std::condition_variable_any condition;
     std::condition_variable wait_condition;
-    std::atomic<size_t> work_scherduled{};
+    std::atomic<size_t> work_scheduled{};
     std::atomic<size_t> work_done{};
     std::atomic<size_t> workers_stopped{};
     std::atomic<size_t> workers_queued{};

src/common/unique_function.h

@@ -14,7 +14,7 @@ class UniqueFunction {
     class CallableBase {
     public:
         virtual ~CallableBase() = default;
-        virtual ResultType operator()(Args...) = 0;
+        virtual ResultType operator()(Args&&...) = 0;
     };
 
     template <typename Functor>
@@ -23,7 +23,7 @@ class UniqueFunction {
         Callable(Functor&& functor_) : functor{std::move(functor_)} {}
         ~Callable() override = default;
 
-        ResultType operator()(Args... args) override {
+        ResultType operator()(Args&&... args) override {
             return functor(std::forward<Args>(args)...);
         }
 
@@ -38,25 +38,20 @@ public:
     UniqueFunction(Functor&& functor)
         : callable{std::make_unique<Callable<Functor>>(std::move(functor))} {}
 
-    UniqueFunction& operator=(UniqueFunction<ResultType, Args...>&& rhs) noexcept {
-        callable = std::move(rhs.callable);
-        return *this;
-    }
+    UniqueFunction& operator=(UniqueFunction&& rhs) noexcept = default;
+    UniqueFunction(UniqueFunction&& rhs) noexcept = default;
 
-    UniqueFunction(UniqueFunction<ResultType, Args...>&& rhs) noexcept
-        : callable{std::move(rhs.callable)} {}
+    UniqueFunction& operator=(const UniqueFunction&) = delete;
+    UniqueFunction(const UniqueFunction&) = delete;
 
-    ResultType operator()(Args... args) const {
+    ResultType operator()(Args&&... args) const {
         return (*callable)(std::forward<Args>(args)...);
     }
 
     explicit operator bool() const noexcept {
-        return callable != nullptr;
+        return static_cast<bool>(callable);
     }
 
-    UniqueFunction& operator=(const UniqueFunction<ResultType, Args...>&) = delete;
-    UniqueFunction(const UniqueFunction<ResultType, Args...>&) = delete;
-
 private:
     std::unique_ptr<CallableBase> callable;
 };