SchedulerContainer.hpp

Go to the documentation of this file.

#pragma once
 
#include "scheduler/AScheduler.hpp"
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <stdexcept>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
namespace Engine {
class Core;

class SchedulerError : public std::exception {
  public:
    explicit SchedulerError(const std::string &message) : msg(fmt::format("Scheduler error: {}", message)) {};

    const char *what() const throw() override { return this->msg.c_str(); };
 
  private:
    std::string msg;
};

class SchedulerContainer {
  public:
    SchedulerContainer() = default;

    ~SchedulerContainer() = default;

    template <typename TScheduler, typename... Args> void AddScheduler(Core &core, Args &&...args);

    template <typename TScheduler> TScheduler &GetScheduler();

    std::shared_ptr<Scheduler::AScheduler> GetScheduler(std::type_index id);

    void RunSchedulers();

    template <typename TScheduler> void DeleteScheduler() { DeleteScheduler(std::type_index(typeid(TScheduler))); }

    void DeleteScheduler(std::type_index id);

    template <typename TBefore, typename TAfter> void Before();

    template <typename TAfter, typename TBefore> void After();

    template <typename TBefore, typename TAfter> void RemoveDependencyBefore();

    template <typename TAfter, typename TBefore> void RemoveDependencyAfter();

    template <typename TScheduler> bool Contains() const;

    bool Contains(std::type_index id) const;

    void SetErrorPolicyForAllSchedulers(Scheduler::SchedulerErrorPolicy policy);
 
  private:
    void Update();

    void TopologicalSort();

    void ProcessDependencies(std::type_index current, std::queue<std::type_index> &q,
                             std::map<std::type_index, size_t> &inDegree) const;
 
  private:
    bool _dirty = false;

    std::map<std::type_index, std::shared_ptr<Scheduler::AScheduler>> _schedulers;

    std::unordered_map<std::type_index, std::unordered_set<std::type_index>> _dependencies;

    std::list<std::shared_ptr<Scheduler::AScheduler>> _orderedSchedulers;
};
} // namespace Engine
 
#include "SchedulerContainer.inl"