GrailDebugInfo.h

// Copyright QED Software 2023.
 
#ifndef GRAIL_DEBUG_INFO_H
#define GRAIL_DEBUG_INFO_H
 
#include "GrailStateSnapshot.h"
#include "PlannerSnapshots.h"
#include "SimulatedGamesSnapshots.h"
#include "UtilityReasonerSnapshot.h"
#include "../DataSerializationVersions.h"
#include "Flatbuffers/GrailDebugInfo_generated.h"
 
#include <map>
#include <vector>
 
namespace grail
{
namespace data
{
 struct GrailDebugInfo
 {
 int version = data_serialization_versions::DEBUG_SERIALIZATION_VERSION;
 float startTime = 0.0f;
 float endTime = 0.0f;
 std::vector<GrailStateSnapshot> grailStateSnapshots{};
 std::map<size_t, std::vector<SimulatedGameReasonerSnapshot>> simGameReasonerSnapshotsPerEntityId{};
 std::map<size_t, std::vector<UtilityReasonerSnapshot>> utilityReasonerSnapshotsPerEntityId{};
 std::map<size_t, std::vector<PlannerReasonerSnapshot>> plannerReasonerSnapshotsPerEntityId{};
 };
 
 inline flatbuffers::Offset<generated::GrailDebugInfo> Pack(flatbuffers::FlatBufferBuilder& builder,
 const GrailDebugInfo& snapshot)
 {
 std::vector<flatbuffers::Offset<generated::GrailStateSnapshot>> packedGrailStates{};
 packedGrailStates.reserve(snapshot.grailStateSnapshots.size());
 std::vector<flatbuffers::Offset<generated::SimulatedGameReasonerSnapshot>> packedSimGames{};
 packedSimGames.reserve(snapshot.simGameReasonerSnapshotsPerEntityId.size());
 std::vector<flatbuffers::Offset<generated::UtilityReasonerSnapshot>> packedUtility{};
 packedUtility.reserve(snapshot.utilityReasonerSnapshotsPerEntityId.size());
 std::vector<flatbuffers::Offset<generated::PlannerReasonerSnapshot>> packedPlanners{};
 packedPlanners.reserve(snapshot.plannerReasonerSnapshotsPerEntityId.size());
 
 std::for_each(snapshot.grailStateSnapshots.begin(), snapshot.grailStateSnapshots.end(),
 [&packedGrailStates, &builder](const auto& state)
 {
 packedGrailStates.push_back(Pack(builder, state));
 });
 std::for_each(snapshot.simGameReasonerSnapshotsPerEntityId.begin(), snapshot.simGameReasonerSnapshotsPerEntityId.end(),
 [&packedSimGames, &builder] (const auto& reasonerSnapshots)
 {
 std::for_each(reasonerSnapshots.second.begin(), reasonerSnapshots.second.end(),
 [&packedSimGames, &builder](const auto reasonerSnapshot)
 {
 packedSimGames.push_back(Pack(builder, reasonerSnapshot));
 });
 });
 std::for_each(snapshot.utilityReasonerSnapshotsPerEntityId.begin(), snapshot.utilityReasonerSnapshotsPerEntityId.end(),
 [&packedUtility, &builder] (const auto& reasonerSnapshots)
 {
 std::for_each(reasonerSnapshots.second.begin(), reasonerSnapshots.second.end(),
 [&packedUtility, &builder](const auto reasonerSnapshot)
 {
 packedUtility.push_back(Pack(builder, reasonerSnapshot));
 });
 });
 std::for_each(snapshot.plannerReasonerSnapshotsPerEntityId.begin(), snapshot.plannerReasonerSnapshotsPerEntityId.end(),
 [&packedPlanners, &builder] (const auto& reasonerSnapshots)
 {
 std::for_each(reasonerSnapshots.second.begin(), reasonerSnapshots.second.end(),
 [&packedPlanners, &builder](const auto reasonerSnapshot)
 {
 packedPlanners.push_back(Pack(builder, reasonerSnapshot));
 });
 });
 
 return generated::CreateGrailDebugInfo(builder,
 snapshot.version,
 snapshot.startTime,
 snapshot.endTime,
 builder.CreateVector(packedGrailStates),
 builder.CreateVector(packedSimGames),
 builder.CreateVector(packedUtility),
 builder.CreateVector(packedPlanners));
 }
 
 inline GrailDebugInfo Unpack(const generated::GrailDebugInfo& snapshot)
 {
 GrailDebugInfo deserializedData{};
 deserializedData.version = snapshot.version();
 deserializedData.startTime = snapshot.startTime();
 deserializedData.endTime = snapshot.endTime();
 
 deserializedData.grailStateSnapshots.reserve(snapshot.grailStateSnapshots()->size());
 for(const auto& grailState : *snapshot.grailStateSnapshots())
 {
 deserializedData.grailStateSnapshots.emplace_back(Unpack(*grailState));
 }
 for(const auto& simGame : *snapshot.simGameReasonerSnapshots())
 {
 deserializedData.simGameReasonerSnapshotsPerEntityId[simGame->entityId()].emplace_back(Unpack(*simGame));
 }
 for(const auto& utility : *snapshot.utilityReasonerSnapshots())
 {
 deserializedData.utilityReasonerSnapshotsPerEntityId[utility->entityId()].emplace_back(Unpack(*utility));
 }
 for(const auto& planner : *snapshot.plannerReasonerSnapshots())
 {
 deserializedData.plannerReasonerSnapshotsPerEntityId[planner->entityId()].emplace_back(Unpack(*planner));
 }
 
 return deserializedData;
 }
}
}
 
#endif