GrailStateSnapshot.h

// Copyright QED Software 2023.
 
#ifndef GRAIL_STATE_SNAPSHOT_H
#define GRAIL_STATE_SNAPSHOT_H
 
#include "BlackboardState.h"
#include "EntityGroupData.h"
#include "EntityState.h"
#include "Flatbuffers/GrailStateSnapshot_generated.h"
 
#include <string>
#include <vector>
 
namespace grail
{
namespace data
{
 struct GrailStateSnapshot
 {
 float absoluteTime = 0.0f;
 float relativeTime = 0.0f;
 std::vector<std::string> tags{};
 std::vector<BlackboardState> sharedBlackboards{};
 std::vector<EntityGroupData> entityGroups{};
 std::vector<EntityState> entityData{};
 };
 
 inline flatbuffers::Offset<generated::GrailStateSnapshot> Pack(flatbuffers::FlatBufferBuilder& builder,
 const GrailStateSnapshot& snapshot)
 {
 std::vector<flatbuffers::Offset<generated::BlackboardState>> packedSharedBlackboards{};
 packedSharedBlackboards.reserve(snapshot.sharedBlackboards.size());
 std::vector<flatbuffers::Offset<generated::EntityGroupData>> packedEntityGroups{};
 packedEntityGroups.reserve(snapshot.entityGroups.size());
 std::vector<flatbuffers::Offset<generated::EntityState>> packedEntityData{};
 packedEntityData.reserve(snapshot.entityData.size());
 std::vector<flatbuffers::Offset<flatbuffers::String>> packedTags{};
 packedTags.reserve(snapshot.tags.size());
 std::for_each(snapshot.tags.begin(), snapshot.tags.end(),
 [&packedTags, &builder](const auto& tag)
 {
 packedTags.push_back(builder.CreateString(tag));
 });
 std::for_each(snapshot.sharedBlackboards.begin(), snapshot.sharedBlackboards.end(),
 [&packedSharedBlackboards, &builder](const auto& blackboard)
 {
 packedSharedBlackboards.push_back(Pack(builder, blackboard));
 });
 std::for_each(snapshot.entityGroups.begin(), snapshot.entityGroups.end(),
 [&packedEntityGroups, &builder](const auto& entityGroup)
 {
 packedEntityGroups.push_back(Pack(builder, entityGroup));
 });
 std::for_each(snapshot.entityData.begin(), snapshot.entityData.end(),
 [&packedEntityData, &builder](const auto& entityData)
 {
 packedEntityData.push_back(Pack(builder, entityData));
 });
 return generated::CreateGrailStateSnapshot(builder,
 snapshot.absoluteTime,
 snapshot.relativeTime,
 builder.CreateVector(packedTags),
 builder.CreateVector(packedSharedBlackboards),
 builder.CreateVector(packedEntityGroups),
 builder.CreateVector(packedEntityData));
 }
 
 inline GrailStateSnapshot Unpack(const generated::GrailStateSnapshot& snapshot)
 {
 GrailStateSnapshot deserializedData{};
 deserializedData.absoluteTime = snapshot.absoluteTime();
 deserializedData.relativeTime = snapshot.relativeTime();
 
 deserializedData.tags.reserve(snapshot.tags()->size());
 for(const auto& tag : *snapshot.tags())
 {
 deserializedData.tags.emplace_back(tag->str());
 }
 deserializedData.sharedBlackboards.reserve(snapshot.sharedBlackboards()->size());
 for(const auto& blackboardState : *snapshot.sharedBlackboards())
 {
 deserializedData.sharedBlackboards.emplace_back(Unpack(*blackboardState));
 }
 deserializedData.entityGroups.reserve(snapshot.entityGroups()->size());
 for(const auto& entityGroup : *snapshot.entityGroups())
 {
 deserializedData.entityGroups.emplace_back(Unpack(*entityGroup));
 }
 deserializedData.entityData.reserve(snapshot.entityData()->size());
 for(const auto& entityData : *snapshot.entityData())
 {
 deserializedData.entityData.emplace_back(Unpack(*entityData));
 }
 return deserializedData;
 }
}
}
 
#endif