SystemManager.hpp

Go to the documentation of this file.

#pragma once
 
#include "NonCopyable.hpp"
#include "Types.hpp"
 
#include <algorithm>
#include <memory>
#include <mutex>
#include <shared_mutex>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <utility>
#include <vector>


class System : public NonCopyable<>
{
public:
 
    virtual ~System() = default;

    virtual void Update(const float deltaT) = 0;

    virtual void Draw() const;
};

class SystemManager
{
public:
 
    SystemManager() = default;
 
    SystemManager(const SystemManager&) = delete;
    SystemManager& operator=(const SystemManager&) = delete;

    template <typename SystemT, typename... Args>
        requires std::is_base_of_v<System, SystemT>
    std::shared_ptr<SystemT> AddSystem(const u32 priority = 1, Args&&... args)
    {
        std::unique_lock lock(m_mutex);
 
        auto ptr = std::make_shared<SystemT>(std::forward<Args>(args)...);
 
        m_systems.push_back(std::make_pair(priority, ptr));
        m_systemsMap.emplace(typeid(SystemT), ptr);
 
        std::sort(m_systems.begin(), m_systems.end(), [](const auto& a, const auto& b)
        {
            return a.first < b.first;
        });
 
        return ptr;
    }

    template <typename SystemT>
        requires std::is_base_of_v<System, SystemT>
    void RemoveSystem()
    {
        std::unique_lock lock(m_mutex);
 
        auto it = m_systemsMap.find(typeid(SystemT));
        if (it == m_systemsMap.end())
        {
            return;
        }
 
        std::shared_ptr<System> ptr = it->second;
        i32 index = -1;
 
        for (u32 i = 0; i < m_systems.size(); ++i)
        {
            if (m_systems[i].second == ptr)
            {
                index = i;
                break;
            }
        }
 
        if (index != -1)
        {
            m_systems.erase(m_systems.begin() + index);
        }
    }

    template <typename SystemT>
        requires std::is_base_of_v<System, SystemT>
    std::shared_ptr<SystemT> GetSystem()
    {
        std::shared_lock lock(m_mutex);
 
        auto it = m_systemsMap.find(typeid(SystemT));
        if (it != m_systemsMap.end())
        {
            return std::dynamic_pointer_cast<SystemT>(it->second);
        }
 
        return nullptr;
    }

    void ClearSystems();
 
private:

    void Update(const float deltaT);

    void Draw();
 
    std::shared_mutex m_mutex;
 
    std::vector<std::pair<u32, std::shared_ptr<System>>> m_systems;
    std::unordered_map<std::type_index, std::shared_ptr<System>> m_systemsMap;
 
    friend class Engine;
};