SynchronizedEntityContainer.h

// Copyright QED Software 2023.
 
#ifndef GRAIL_SYNCHRONIZED_ENTITY_CONTAINER_H
#define GRAIL_SYNCHRONIZED_ENTITY_CONTAINER_H
 
#include <map>
#include <mutex>
#include <set>
#include "AIEntity.hh"
 
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 MarkDone(std::size_t index);
        ProcessingStatus GetStatus(std::size_t index);
        bool IsDone();
        bool IsEntityPriorityValid(std::size_t index);
        int GetCurrentPriority();
 
    private:
        void SetNextPriority();
        void MarkDoneNonBlocking(std::size_t index);
 
        std::vector<std::pair<std::shared_ptr<AIEntity>, int>> data{};
        std::size_t dataDone{};
        std::size_t priorityDone{};
        std::mutex mutex{};
 
        int lowestPriority = {std::numeric_limits<int>::max()};
        int highestPriority = {std::numeric_limits<int>::min()};
        int currentPriority = {0};
        std::map<int, std::size_t> entitiesPerPriority{};
    };
}
 
#endif  //GRAIL_SYNCHRONIZED_ENTITY_CONTAINER_H