PlannerSnapshots.h

// Copyright QED Software 2023.
 
#ifndef GRAIL_PLANNER_SNAPSHOT_H
#define GRAIL_PLANNER_SNAPSHOT_H
 
#include "Flatbuffers/PlannerWorldObjectSnapshot_generated.h"
#include "Flatbuffers/PlannerActionSnapshot_generated.h"
#include "Flatbuffers/PlannerIterationSnapshot_generated.h"
#include "Flatbuffers/PlannerReasonerSnapshot_generated.h"
 
#include <limits>
#include <map>
#include <string>
#include <utility>
#include <vector>
 
namespace grail
{
 namespace planner
 {
 class WorldState;
 class Action;
 class ParametrizedObject;
 }
 
namespace data
{
 struct PlannerWorldObjectSnapshot
 {
 std::string typeName;
 unsigned int objectId = 0;
 
 std::map<std::string, std::string> objectData{};
 };
 
 flatbuffers::Offset<generated::PlannerWorldObjectSnapshot> Pack(flatbuffers::FlatBufferBuilder& builder,
 const PlannerWorldObjectSnapshot& snapshot);
 PlannerWorldObjectSnapshot Unpack(const generated::PlannerWorldObjectSnapshot& snapshot);
 
 struct PlannerActionSnapshot
 {
 std::string name{};
 std::vector<std::string> parametrization{};
 std::vector<PlannerWorldObjectSnapshot> resultingWorldState{};
 
 PlannerActionSnapshot(const planner::Action& action,
 const planner::WorldState& worldState,
 const planner::WorldState& previousWorldState);
 PlannerActionSnapshot() = default;
 
 private:
 void AddParametrizedObjectSnapshot(const planner::ParametrizedObject& parametrizedObject,
 unsigned int objectId,
 const std::string& objectName);
 };
 
 flatbuffers::Offset<generated::PlannerActionSnapshot> Pack(flatbuffers::FlatBufferBuilder& builder,
 const PlannerActionSnapshot& snapshot);
 PlannerActionSnapshot Unpack(const generated::PlannerActionSnapshot& snapshot);
 
 struct PlannerIterationSnapshot
 {
 std::size_t iterationNumber = 0;
 
 std::vector<PlannerActionSnapshot> planActions = {};
 
 bool goalReached = false;
 
 double score = 0;
 double totalCost = std::numeric_limits<double>::max();
 PlannerIterationSnapshot(std::size_t keyIterationIndex);
 PlannerIterationSnapshot() = default;
 };
 
 flatbuffers::Offset<generated::PlannerIterationSnapshot> Pack(flatbuffers::FlatBufferBuilder& builder,
 const PlannerIterationSnapshot& snapshot);
 PlannerIterationSnapshot Unpack(const generated::PlannerIterationSnapshot& snapshot);
 
 
 struct PlannerReasonerSnapshot
 {
 std::vector<PlannerIterationSnapshot> iterations = {};
 
 float absoluteTime = 0;
 float relativeTime = 0;
 std::size_t entityId = 0;
 };
 
 flatbuffers::Offset<generated::PlannerReasonerSnapshot> Pack(flatbuffers::FlatBufferBuilder& builder,
 const PlannerReasonerSnapshot& snapshot);
 PlannerReasonerSnapshot Unpack(const generated::PlannerReasonerSnapshot& snapshot);
}
}
 
#endif