Merge remote-tracking branch 'nao/master'

No conflits, YEEESS

3 files changed, 43 insertions, 27 deletions

diff --git a/engine/include/core/priority.hpp b/engine/include/core/priority.hpp
index 1219d26..ae4a6db 100644
--- a/engine/include/core/priority.hpp
+++ b/engine/include/core/priority.hpp
@@ -16,29 +16,24 @@ namespace flat {
         };
 
         class prioritized {
-        private:
-            const priority_t m_priority;
-
         public:
-            prioritized(priority_t priority = priority_t::none)
-                : m_priority(priority) {}
+            const priority_t priority;
 
-            const priority_t priority() const {
-                return m_priority;
-            }
+            prioritized(priority_t p = priority_t::none)
+                : priority(p) {}
         };       
 
         struct prioritize {
             bool operator()(const prioritized& lhs, const prioritized& rhs) {
-                return lhs.priority() < rhs.priority();
+                return lhs.priority < rhs.priority;
             }
 
-            bool operator()(const std::weak_ptr<prioritized> lhs, const std::weak_ptr<prioritized>& rhs) {
+            bool operator()(const std::weak_ptr<prioritized> lhs, const std::weak_ptr<prioritized> rhs) {
                 if (auto l = lhs.lock()) {
                     if (auto r = rhs.lock()) {
                         // if both valid, check their priority
                         // in case they are the same, left is prioritized
-                        return l->priority() < r->priority();
+                        return l->priority < r->priority;
                     } else {
                         // if right is expired, left is prioritized
                         return true;
diff --git a/engine/include/core/task.hpp b/engine/include/core/task.hpp
index d886fcd..77e1da6 100644
--- a/engine/include/core/task.hpp
+++ b/engine/include/core/task.hpp
@@ -2,7 +2,9 @@
 
 #include "priority.hpp"
 
+#include <unordered_set>
 #include <functional>
+#include <variant>
 #include <memory>
 
 namespace flat {
@@ -13,6 +15,7 @@ namespace flat {
 
         class task : public prioritized {
         public:
+            using ptr = std::shared_ptr<task>;
             using callback = std::function<void(void)>;
 
             task() = delete;
@@ -24,9 +27,24 @@ namespace flat {
             callback m_callback;
         };
 
-        struct job : private queue<std::weak_ptr<task>> {
-            std::shared_ptr<task> make_task(task::callback f, priority_t p = priority_t::none);
+        class job : protected queue<std::weak_ptr<task>> {
+        public:
+            /// add a task function owned by the job object
+            void add_task(task::callback f, priority_t p);
+
+            /// add a task function not owned by the job object (weak_ptr)
+            std::shared_ptr<task> delegate_task(task::callback f, priority_t p = priority_t::none);
+
+            /// add a task methods not owned by the job object (weak_ptr),
+            ///  this allows to make the task die when the owner object goes out of scope
+            template<typename R, typename T>
+            inline std::shared_ptr<task> delegate_task(R T::*mf, T& obj, priority_t p = priority_t::none) {
+                return delegate_task(std::bind(mf, obj), p);
+            }
+
+            /// run tasks
             void invoke_tasks();
+            inline void operator()() { invoke_tasks(); } 
         };
     }
 }
diff --git a/engine/task.cpp b/engine/task.cpp
index 7f1b08b..9cfbec4 100644
--- a/engine/task.cpp
+++ b/engine/task.cpp
@@ -2,6 +2,8 @@
 
 #include <functional>
 #include <memory>
+#include <algorithm>
+#include <cassert>
 
 #include <vector>
 
@@ -14,31 +16,32 @@ namespace flat {
         task::task(task::callback f, priority_t p)
             : m_callback(f) {}
 
-        std::shared_ptr<task> job::make_task(task::callback f, priority_t p) {
-
+        std::shared_ptr<task> job::delegate_task(task::callback f, priority_t p) {
             auto shared = std::make_shared<task>(f, p);
             insert(shared);
+
             return shared;
         }
 
-        void job::invoke_tasks() {
-            //std::for_each(begin(), end(), [&](auto tp) {
+        void job::add_task(task::callback f, priority_t p) {
+            insert(std::make_shared<task>(f, p));
+        }
 
-            vector<weak_ptr<task>> to_erase;
+        void job::invoke_tasks() {
+            // expired tasks to remove
+            std::vector<job::value_type> to_erase;
 
-            for (auto tp : (*this)) {
-                if (tp.expired())
+            for (auto tp : *this) {
+                // check that the task has not expired
+                if (std::shared_ptr<task> t = tp.lock())
+                    std::invoke(*t);
+                else
                     to_erase.push_back(tp);
             }
 
-            for (auto tp : to_erase)
+            // delete expired tasks
+            for (auto tp : to_erase) {
                 erase(tp);
-
-            for (auto tp : (*this)) {
-                // check that the task has not expired
-                    // run task
-                    auto t = tp.lock();
-                    std::invoke(*t);
             }
         }