DebugInfoGenerator.h

#pragma once
 
#include "IDebugSnapshotReceiver.h"
#include "ITimestampProvider.h"
#include "../../GrailData/DebugInfo/GrailDebugInfo.h"
 
#include <cmath>
#include <memory>
 
namespace grail
{
    class DebugInfoGenerator : public IDebugSnapshotReceiver
    {
    public:
        DebugInfoGenerator(const std::shared_ptr<ITimestampProvider>& timestampProvider);
        ~DebugInfoGenerator() override;
 
        const GrailDebugInfo& GetDebugInfo() const;
        void ResetDebugInfo();
        void ProcessSnapshot(GrailStateSnapshot& snapshot) override;
        void ProcessSnapshot(UtilityReasonerSnapshot& snapshot) override;
        void ProcessSnapshot(PlannerReasonerSnapshot& snapshot) override;
        void ProcessSnapshot(SimulatedGameReasonerSnapshot& snapshot) override;
 
    private:
        template<typename SnapshotType>
        void ProcessNewSnapshot(SnapshotType& snapshot,
            std::vector<SnapshotType>& snapshotList)
        {
            debugInfo.endTime = std::fmax(snapshot.absoluteTime, debugInfo.endTime);
            snapshot.relativeTime = timestampProvider->GetTimestamp() - debugInfo.startTime;
            snapshotList.push_back(snapshot);
        }
 
        template<typename SnapshotType>
        void ProcessReasonerSnapshot(SnapshotType& reasonerSnapshot,
            std::map<size_t, std::vector<SnapshotType>>& listsPerEntity,
            size_t entityId)
        {
            auto iter = listsPerEntity.find(entityId);
            if (iter == listsPerEntity.end())
            {
                std::vector<SnapshotType> snapshots;
                ProcessNewSnapshot(reasonerSnapshot, snapshots);
                listsPerEntity[entityId] = std::move(snapshots);
            }
            else
            {
                ProcessNewSnapshot(reasonerSnapshot, iter->second);
            }
        }
 
 
        std::shared_ptr<ITimestampProvider> timestampProvider = nullptr;
        GrailDebugInfo debugInfo{};
    };
}