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