SynchronizedEntityContainer.h

#ifndef GRAIL_SYNCHRONIZED_ENTITY_CONTAINER_H
#define GRAIL_SYNCHRONIZED_ENTITY_CONTAINER_H
 
#include "AIEntity.hh"
#include <mutex>
#include <map>
 
namespace grail
{
    class AIEntity;
 
    class SynchronizedEntityContainer final
    {
    public:
        SynchronizedEntityContainer();
 
        SynchronizedEntityContainer(const SynchronizedEntityContainer&) = delete;
        SynchronizedEntityContainer(SynchronizedEntityContainer&&) = delete;
 
        SynchronizedEntityContainer& operator = (const SynchronizedEntityContainer&) = delete;
        SynchronizedEntityContainer& operator = (SynchronizedEntityContainer&&) = delete;
        const std::pair<std::shared_ptr<AIEntity>, int> operator [](std::size_t index);
 
        void SetData(const std::vector<std::pair<std::shared_ptr<AIEntity>, int>>& newData);
        std::size_t Size();
        void ChangeStatus(std::size_t index, Status newStatus);
        Status GetStatus(std::size_t index);
        bool IsDone();
        int GetCurrentPriority();
        void SetNextPriority();
 
    private:
        std::vector<std::pair<std::shared_ptr<AIEntity>, int>> data{};
        std::atomic<std::size_t> dataDone{};
        std::atomic<std::size_t> priorityDone{};
        std::mutex mutex{};
 
        std::atomic<int> lowestPriority = { std::numeric_limits<int>::max() };
        std::atomic<int> highestPriority = { std::numeric_limits<int>::min() };
        std::atomic<int> currentPriority = { 0 };
        std::map<int, std::atomic<std::size_t>> entitiesPerPriority{};
    };
}
 
#endif  //GRAIL_SYNCHRONIZED_ENTITY_CONTAINER_H