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