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