* started implementation of atomic counter scheduler

include/ecs/context/base.h

@@ -125,6 +125,12 @@ beg_namespace_ecs_context
             }
 
         protected: /* systems */
+            template<typename T_system_tag>
+            inline auto& instance(T_system_tag st)
+            {
+                return _systems.instance_by_tag(st);
+            }
+
             template<typename T_system_tag>
             inline auto& system(T_system_tag st)
             {
@@ -184,7 +190,7 @@ beg_namespace_ecs_context
                 auto tags = make_system_tag_list(std::forward<T_system_tags>(sts)...);
                 return [tags, this](auto&&... fns) {
                     auto os = hana::overload_linearly(std::forward<decltype(fns)>(fns)...);
-                    this->_scheduler.execute(*this, tags, os);
+                    this->_scheduler.execute(tags, os);
                 };
             }
         };

include/ecs/core/system/scheduler/atomic_counter.h

@@ -5,6 +5,45 @@
 beg_namespace_ecs_core_system_scheduler
 {
 
+    namespace __impl
+    {
+        template<typename T_system_tag, typename T_dependencies>
+        struct dependencie_item_t
+        {
+            using system_tag_type   = T_system_tag;
+            using dependencies_type = T_dependencies;
+
+            system_tag_type     tag;
+            dependencies_type   dependencies;
+        };
+
+        template<typename T_system_signature_list, typename T_system_tag_list>
+        constexpr decltype(auto) build_dependencie_list(T_system_signature_list ssl, T_system_tag_list stl)
+        {
+            auto filtered = hana::filter(ssl, [stl](auto& ssig){
+                return hana::contains(stl, mp::unwrap(ssig).tag());
+            });
+            return hana::transform(filtered, [](auto& ssig){
+                auto tag  = mp::unwrap(ssig).tag();
+                auto deps = hana::filter(mp::unwrap(ssig).dependencies(), [](auto& tag){
+                                return hana::contains(T_system_tag_list { }, tag);
+                            });
+                using tag_type  = mp::decay_t<decltype(tag)>;
+                using dep_type  = mp::decay_t<decltype(deps)>;
+                using item_type = dependencie_item_t<tag_type, dep_type>;
+                return item_type { };
+            });
+        }
+
+        template<typename T_dependency_list>
+        constexpr decltype(auto) get_independent_items(T_dependency_list deps) noexcept
+        {
+            return hana::filter(deps, [](auto& item){
+                return hana::size(item.dependencies) == hana::size_c<0>;
+            });
+        }
+    }
+
     template<typename T_settings>
     struct atomic_counter
     {
@@ -12,9 +51,31 @@ beg_namespace_ecs_core_system_scheduler
         using settings_type = T_settings;
 
     public:
-        template<typename... T_args>
-        inline void execute(T_args&&...)
-            { }
+        template<typename T_system_tag_list, typename T_func>
+        inline void execute(T_system_tag_list stl, T_func&& func)
+        {
+            static_assert(tag::system::is_list(stl));
+            auto dependencie_list  = __impl::build_dependencie_list((settings_type { }).system_signatures().items, stl);
+            auto independent_items = __impl::get_independent_items(dependencie_list);
+
+            std::cout << "dependencie_list" << std::endl;
+            hana::for_each(dependencie_list, [](auto& item){
+                using system_type = mp::unwrap_t<mp::decay_t<decltype(item.tag)>>;
+                std::cout << "  " << type_helper<system_type>::name() << std::endl;
+                hana::for_each(item.dependencies, [](auto& tag){
+                    std::cout << "    " << type_helper<mp::unwrap_t<mp::decay_t<decltype(tag)>>>::name() << std::endl;
+                });
+            });
+
+            std::cout << "independent_items" << std::endl;
+            hana::for_each(independent_items, [](auto& item){
+                using system_type = mp::unwrap_t<mp::decay_t<decltype(item.tag)>>;
+                std::cout << "  " << type_helper<system_type>::name() << std::endl;
+                hana::for_each(item.dependencies, [](auto& tag){
+                    std::cout << "    " << type_helper<mp::unwrap_t<mp::decay_t<decltype(tag)>>>::name() << std::endl;
+                });
+            });
+        }
     };
 
 }

include/ecs/core/utils/counter_blocker.h

@@ -19,6 +19,13 @@ beg_namespace_ecs_core_utils
             : _counter(counter)
             { }
 
+        inline void increment() noexcept
+        {
+            std::lock_guard lock(_mutex);
+            assert(_counter > 0);
+            ++_counter;
+        }
+
         inline void decrement_and_notify_one() noexcept
         {
             std::lock_guard lock(_mutex);

test/dummy.cpp

@@ -47,17 +47,17 @@ namespace test
     namespace system
     {
         struct accelerate
-        {
-            int fuu { 6 };
-        };
+            { };
 
         struct move
-        {
-            int bar;
-        };
+            { };
+
+        struct render
+            { };
 
         MAKE_SYSTEM_TAG(accelerate)
         MAKE_SYSTEM_TAG(move)
+        MAKE_SYSTEM_TAG(render)
     }
 }
 
@@ -103,9 +103,15 @@ constexpr decltype(auto) ss_move =
         .read(ct::velocity)
         .write(ct::position);
 
+constexpr decltype(auto) ss_render = 
+    ss::make(st::render)
+        .dependencies(st::move)
+        .read(ct::velocity, ct::position, ct::acceleration);
+
 constexpr decltype(auto) ss_list = ssl::make(
     ss_accelerate,
-    ss_move);
+    ss_move,
+    ss_render);
 
 constexpr decltype(auto) settings = ::ecs::settings::make()
     .component_signatures(cs_list)
@@ -117,7 +123,7 @@ TEST(DummyTest, fuu)
 {
     auto context = ::ecs::context::make(settings);
     context.step([](auto& step_proxy){
-        step_proxy.execute_systems()(
+        step_proxy.execute_systems(st::accelerate, st::render)(
             sea::tags(st::accelerate)
                 .for_subtasks([](auto& s, auto& data){
                     std::cout << "accelerate" << std::endl;
@@ -125,6 +131,10 @@ TEST(DummyTest, fuu)
             sea::tags(st::move)
                 .for_subtasks([](auto& s, auto& data){
                     std::cout << "move" << std::endl;
+                }),
+            sea::tags(st::render)
+                .for_subtasks([](auto& s, auto& data){
+                    std::cout << "render" << std::endl;
                 })
         );
     });