SystemFactory.hpp

Go to the documentation of this file.

 
 
#ifndef GALAXY_META_SYSTEMFACTORY_HPP_
#define GALAXY_META_SYSTEMFACTORY_HPP_
 
#include <ankerl/unordered_dense.h>
 
#include "galaxy/math/FNV1a.hpp"
#include "galaxy/meta/Concepts.hpp"
#include "galaxy/logging/Log.hpp"
 
namespace galaxy
{
    namespace systems
    {
        class System;
    } // namespace systems
 
    namespace meta
    {
        using SystemStack = std::vector<std::unique_ptr<systems::System>>;
 
        class SystemFactory final
        {
        public:
            SystemFactory() noexcept = default;
 
            ~SystemFactory() noexcept = default;
 
            template<valid_component System>
            void register_system(const std::string& name);
 
            void create_system(const std::string& name, SystemStack& stack);
 
        private:
            ankerl::unordered_dense::map<std::uint64_t, std::move_only_function<void(SystemStack&)>> m_factory;
        };
 
        template<valid_component System>
        inline void SystemFactory::register_system(const std::string& name)
        {
            const auto hash = math::fnv1a(name.c_str());
            if (!m_factory.contains(hash))
            {
                m_factory.emplace(hash, [](SystemStack& stack) {
                    for (auto&& sys : stack)
                    {
                        if (sys->id() == name)
                        {
                            GALAXY_LOG(GALAXY_WARNING, "Tried to create a create a duplicate system '{0}'.", name);
                            return;
                        }
                    }
 
                    stack.emplace_back(std::move(std::make_unique<System>()));
                });
            }
            else
            {
                GALAXY_LOG(GALAXY_WARNING, "Tried to create a duplicate register system '{0}'.", name);
            }
        }
    } // namespace meta
} // namespace galaxy
 
#endif