EntityGroupData.h

// Copyright QED Software 2023.
 
#ifndef GRAIL_ENTITY_GROUP_DATA_H
#define GRAIL_ENTITY_GROUP_DATA_H
 
#include <vector>
#include "BlackboardState.h"
#include "Flatbuffers/EntityGroupData_generated.h"
#include "Flatbuffers/UintVectorOfStringMap_generated.h"
 
namespace grail
{
namespace data
{
    struct EntityGroupData
    {
        std::string name{};
        unsigned int id = 0;
        std::vector<unsigned int> entityIds{};
        std::vector<BlackboardState> groupSharedBlackboardStates{};
        std::map<unsigned int, std::vector<std::string>> groupBlackboardConnections{};
        std::map<unsigned int, std::vector<std::string>> globalBlackboardConnections{};
    };
 
    inline flatbuffers::Offset<generated::EntityGroupData> Pack(flatbuffers::FlatBufferBuilder& builder,
                                                                        const EntityGroupData& entityGroupData)
    {
        std::vector<flatbuffers::Offset<generated::UintVectorOfStringMap>> packedGroupConnections{};
        packedGroupConnections.reserve(entityGroupData.groupBlackboardConnections.size());
        std::vector<flatbuffers::Offset<generated::UintVectorOfStringMap>> packedGlobalConnections{};
        packedGlobalConnections.reserve(entityGroupData.globalBlackboardConnections.size());
        std::vector<unsigned int> packedEntityIds{};
        packedEntityIds.reserve(entityGroupData.entityIds.size());
        std::vector<flatbuffers::Offset<generated::BlackboardState>> packedBlackboardStates{};
        packedBlackboardStates.reserve(entityGroupData.groupSharedBlackboardStates.size());
        std::for_each(entityGroupData.groupBlackboardConnections.begin(), entityGroupData.groupBlackboardConnections.end(),
                      [&packedGroupConnections, &builder](const auto& connection)
                      {
                          packedGroupConnections.push_back(generated::CreateUintVectorOfStringMap(builder,
                                                               connection.first, builder.CreateVectorOfStrings(connection.second)));
                      });
        std::for_each(entityGroupData.globalBlackboardConnections.begin(), entityGroupData.globalBlackboardConnections.end(),
                      [&packedGlobalConnections, &builder](const auto& connection)
                      {
                          packedGlobalConnections.push_back(generated::CreateUintVectorOfStringMap(builder,
                                                                connection.first, builder.CreateVectorOfStrings(connection.second)));
                      });
        std::for_each(entityGroupData.entityIds.begin(), entityGroupData.entityIds.end(), [&packedEntityIds](const auto& entityId)
        {
            packedEntityIds.emplace_back(entityId);
        });
        std::for_each(entityGroupData.groupSharedBlackboardStates.begin(), entityGroupData.groupSharedBlackboardStates.end(),
                      [&packedBlackboardStates, & builder](const auto& state)
                      {
                          packedBlackboardStates.emplace_back(Pack(builder, state));
                      });
        return generated::CreateEntityGroupData(builder, builder.CreateString(entityGroupData.name), entityGroupData.id,
                                                builder.CreateVector(packedEntityIds), builder.CreateVector(packedBlackboardStates),
                                                builder.CreateVector(packedGroupConnections),
                                                builder.CreateVector(packedGlobalConnections));
    }
 
    inline EntityGroupData Unpack(const generated::EntityGroupData& entityGroupData)
    {
        EntityGroupData deserializedData{entityGroupData.name()->str(), entityGroupData.id()};
 
        deserializedData.entityIds.reserve(entityGroupData.entityIds()->size());
        for(const auto& id : *entityGroupData.entityIds())
        {
            deserializedData.entityIds.emplace_back(id);
        }
        deserializedData.groupSharedBlackboardStates.reserve(entityGroupData.groupSharedBlackboardStates()->size());
        for(const auto& blackboardState : *entityGroupData.groupSharedBlackboardStates())
        {
            deserializedData.groupSharedBlackboardStates.emplace_back(Unpack(*blackboardState));
        }
        for(const auto& groupConnection : *entityGroupData.groupBlackboardConnections())
        {
            std::vector<std::string> blackboardIds{};
            for(const auto& entry : *groupConnection->value())
            {
                blackboardIds.emplace_back(entry->str());
            }
            deserializedData.groupBlackboardConnections.insert({groupConnection->key(), blackboardIds});
        }
        for(const auto& globalConnection : *entityGroupData.globalBlackboardConnections())
        {
            std::vector<std::string> blackboardIds{};
            for(const auto& entry : *globalConnection->value())
            {
                blackboardIds.emplace_back(entry->str());
            }
            deserializedData.globalBlackboardConnections.insert({globalConnection->key(), blackboardIds});
        }
        return deserializedData;
    }
}
}
 
#endif