EntityState.h

// Copyright QED Software 2023.
 
#ifndef GRAIL_ENTITY_STATE_H
#define GRAIL_ENTITY_STATE_H
 
#include "BehaviorData.h"
#include "Flatbuffers/EntityState_generated.h"
 
#include <map>
#include <string>
#include <vector>
 
namespace grail
{
namespace data
{
    struct EntityState
    {
        std::string name{};
        size_t id = 0;
        std::map<std::string, std::string> privateBlackboardData{};
        std::vector<std::string> localSharedBlackboardAccess{};
        std::vector<std::string> globalSharedBlackboardAccess{};
        std::vector<std::string> entityTags{};
        BehaviorData currentBehaviorData{};
    };
 
    inline flatbuffers::Offset<generated::EntityState> Pack(flatbuffers::FlatBufferBuilder& builder,
                                                            const EntityState& entityState)
    {
        std::vector<flatbuffers::Offset<generated::StringStringMap>> packedPrivateBlackboards{};
        packedPrivateBlackboards.reserve(entityState.privateBlackboardData.size());
        std::vector<flatbuffers::Offset<flatbuffers::String>> packedLocalBlackboards{};
        packedLocalBlackboards.reserve(entityState.localSharedBlackboardAccess.size());
        std::vector<flatbuffers::Offset<flatbuffers::String>> packedGlobalBlackboards{};
        packedGlobalBlackboards.reserve(entityState.globalSharedBlackboardAccess.size());
        std::vector<flatbuffers::Offset<flatbuffers::String>> packedTags{};
        packedTags.reserve(entityState.entityTags.size());
 
        std::for_each(entityState.privateBlackboardData.begin(), entityState.privateBlackboardData.end(),
                      [&packedPrivateBlackboards, &builder](const auto& blackboardData)
                      {
                          packedPrivateBlackboards.push_back(generated::CreateStringStringMap(builder,
                                                                                              builder.CreateString(blackboardData.first),
                                                                                              builder.CreateString(blackboardData.second)));
                      });
        std::for_each(entityState.localSharedBlackboardAccess.begin(), entityState.localSharedBlackboardAccess.end(),
                      [&packedLocalBlackboards, &builder](const auto& blackboardName)
                      {
                          packedLocalBlackboards.push_back(builder.CreateString(blackboardName));
                      });
        std::for_each(entityState.globalSharedBlackboardAccess.begin(), entityState.globalSharedBlackboardAccess.end(),
                      [&packedGlobalBlackboards, &builder](const auto& blackboardName)
                      {
                          packedGlobalBlackboards.push_back(builder.CreateString(blackboardName));
                      });
        std::for_each(entityState.entityTags.begin(), entityState.entityTags.end(),
                      [&packedTags, &builder](const auto& entityTag)
                      {
                          packedTags.push_back(builder.CreateString(entityTag));
                      });
        return generated::CreateEntityState(builder,
                                            builder.CreateString(entityState.name),
                                            entityState.id,
                                            builder.CreateVector(packedPrivateBlackboards),
                                            builder.CreateVector(packedLocalBlackboards),
                                            builder.CreateVector(packedGlobalBlackboards),
                                            builder.CreateVector(packedTags),
                                            Pack(builder, entityState.currentBehaviorData));
    }
 
    inline EntityState Unpack(const generated::EntityState& entityState)
    {
        EntityState deserializedState{entityState.name()->str(), entityState.id()};
        for(const auto& blackboardData : *entityState.privateBlackboardData())
        {
            deserializedState.privateBlackboardData.insert({blackboardData->key()->str(), blackboardData->value()->str()});
        }
        deserializedState.localSharedBlackboardAccess.reserve(entityState.localSharedBlackboardAccess()->size());
        for(const auto& blackboardName : *entityState.localSharedBlackboardAccess())
        {
            deserializedState.localSharedBlackboardAccess.emplace_back(blackboardName->str());
        }
        deserializedState.globalSharedBlackboardAccess.reserve(entityState.globalSharedBlackboardAccess()->size());
        for(const auto& blackboardName : *entityState.globalSharedBlackboardAccess())
        {
            deserializedState.globalSharedBlackboardAccess.emplace_back(blackboardName->str());
        }
        deserializedState.entityTags.reserve(entityState.entityTags()->size());
        for(const auto& entityTag : *entityState.entityTags())
        {
            deserializedState.entityTags.emplace_back(entityTag->str());
        }
        deserializedState.currentBehaviorData = Unpack(*entityState.currentBehaviorData());
        return deserializedState;
    }
}
}
 
#endif