TaskOutcomeDebugger.h

Go to the documentation of this file.

#pragma once
 
#include <ArmarXCore/core/Component.h>
 
#include <RobotAPI/libraries/armem/client/MemoryNameSystem.h>
#include <RobotAPI/libraries/armem/client/plugins.h>
#include <RobotAPI/libraries/armem/client/plugins/ListeningPluginUser.h>
 
#include <RobotAPI/libraries/armem_task_outcome/client/TaskOutcomeReader.h>
#include <RobotAPI/libraries/armem_task_outcome/client/TaskOutcomeWriter.h>
#include <RobotAPI/libraries/armem_task_outcome/types.h>
 
namespace armarx::components::task_outcome_debugger
{
 
    /**
     * Interactive debugger component for the TaskOutcome memory.
     *
     * Allows committing and querying task outcomes via terminal commands.
     * The TaskOutcomeMemory server must be running.
     *
     * Commands:
     *   commit <taskName> <taskType> <outcome> [errorMessage]
     *   read                    - read all task outcomes
     *   read_type <taskType>    - read outcomes filtered by task type
     *   read_failures           - read only failures
     *   exit                    - exit the debugger
     */
    class TaskOutcomeDebugger :
        virtual public armarx::Component,
        virtual public armarx::armem::client::ComponentPluginUser
    {
    public:
        std::string getDefaultName() const override;
        static std::string GetDefaultName();
 
    public:
        static const std::string providerName;
 
    protected:
        armarx::PropertyDefinitionsPtr createPropertyDefinitions() override;
 
        void onInitComponent() override;
        void onConnectComponent() override;
        void onDisconnectComponent() override;
        void onExitComponent() override;
 
    private:
        void run();
 
        // Commands
        void commitCommand();
        void readAllCommand();
        void readByTypeCommand();
        void readFailuresCommand();
 
        // Helpers
        void commitOutcome(const std::string& taskName,
                           armem::task_outcome::TaskType taskType,
                           armem::task_outcome::TaskOutcomeType outcomeType,
                           const std::optional<std::string>& errorMessage);
 
        void printOutcomes(const std::vector<armem::task_outcome::TaskOutcome>& outcomes);
 
        static armem::task_outcome::TaskOutcomeType
        parseOutcomeType(const std::string& str);
 
        static armem::task_outcome::TaskType
        parseTaskType(const std::string& str);
 
        static std::string outcomeTypeToString(armem::task_outcome::TaskOutcomeType type);
        static std::string taskTypeToString(armem::task_outcome::TaskType type);
        static std::string failureTypeToString(const armem::task_outcome::FailureType& type);
 
    private:
        bool running = false;
 
        armem::task_outcome::client::TaskOutcomeWriter writer;
        armem::task_outcome::client::TaskOutcomeReader reader;
    };
 
} // namespace armarx::components::task_outcome_debugger