SystemManager.h

#pragma once
 
#include "Types.h"
 
#include <algorithm>
#include <memory>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <utility>
#include <vector>
 
class System
{
public:
 
    virtual ~System()
    {
    }
 
    virtual void Update(const float deltaT) = 0;
 
    virtual void Draw() = 0;
};
 
class SystemManager
{
public:
 
    void Update(const float deltaT);
 
    void Draw();
 
    template <typename T, typename... Args>
        requires std::is_base_of_v<System, T>
    T& AddSystem(const u32 priority = 1, Args&&... args)
    {
        auto ptr = std::make_unique<T>(std::forward<Args>(args)...);
        T& ref = *ptr;
 
        m_systems.push_back(std::make_pair(priority, std::move(ptr)));
        m_systemsMap.emplace(typeid(T), ptr.get());
 
        std::sort(m_systems.begin(), m_systems.end(), [](const auto& a, const auto& b)
        {
            return a.first > b.first;
        });
 
        return ref;
    }
 
    template <typename T>
        requires std::is_base_of_v<System, T>
    void RemoveSystem()
    {
        auto it = m_systemsMap.find(typeid(T));
        if (it == m_systemsMap.end())
        {
            return;
        }
 
        System* ptr = it->second;
        i32 index = -1;
 
        for (u32 i = 0; i < m_systems.size(); ++i)
        {
            if (m_systems[i].second.get() == ptr)
            {
                index = 0;
                break;
            }
        }
 
        if (index != -1)
        {
            m_systems.erase(m_systems.begin() + index);
        }
    }
 
    template <typename T>
        requires std::is_base_of_v<System, T>
    T* GetSystem()
    {
        auto it = m_systemsMap.find(typeid(T));
        if (it != m_systemsMap.end())
        {
            return it->second;
        }
 
        return nullptr;
    }
 
    void ClearSystems();
 
private:
 
    std::vector<std::pair<u32, std::unique_ptr<System>>> m_systems;
    std::unordered_map<std::type_index, System*> m_systemsMap;
};