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