aron_conversions.cpp

Go to the documentation of this file.

#include "aron_conversions.h"
 
#include <nlohmann/json.hpp>
 
#include <RobotAPI/libraries/aron/common/aron_conversions/time.h>
 
namespace armarx::armem::task_outcome
{
 
    template <class DTOType, class BOType>
    static void
    fromAronOptional(const std::optional<DTOType>& dtoOpt, std::optional<BOType>& boOpt)
    {
        if (dtoOpt.has_value())
        {
            BOType bo;
            fromAron(dtoOpt.value(), bo);
            boOpt = bo;
        }
        else
        {
            boOpt = std::nullopt;
        }
    }
 
    template <class DTOType, class BOType>
    static void
    toAronOptional(std::optional<DTOType>& dtoOpt, const std::optional<BOType>& boOpt)
    {
        if (boOpt.has_value())
        {
            DTOType dto;
            toAron(dto, boOpt.value());
            dtoOpt = dto;
        }
        else
        {
            dtoOpt = std::nullopt;
        }
    }
 
    // --- TaskOutcomeType ---
 
    void
    fromAron(const armarx::task_outcome::arondto::TaskOutcomeType& dto, TaskOutcomeType& bo)
    {
        switch (dto.value)
        {
            case armarx::task_outcome::arondto::TaskOutcomeType::UNKNOWN:
                bo = TaskOutcomeType::UNKNOWN;
                break;
            case armarx::task_outcome::arondto::TaskOutcomeType::SUCCESS:
                bo = TaskOutcomeType::SUCCESS;
                break;
            case armarx::task_outcome::arondto::TaskOutcomeType::FAILURE:
                bo = TaskOutcomeType::FAILURE;
                break;
            case armarx::task_outcome::arondto::TaskOutcomeType::ABORTED:
                bo = TaskOutcomeType::ABORTED;
                break;
            case armarx::task_outcome::arondto::TaskOutcomeType::SUSPENDED:
                bo = TaskOutcomeType::SUSPENDED;
                break;
        }
    }
 
    void
    toAron(armarx::task_outcome::arondto::TaskOutcomeType& dto, const TaskOutcomeType& bo)
    {
        switch (bo)
        {
            case TaskOutcomeType::UNKNOWN:
                dto = armarx::task_outcome::arondto::TaskOutcomeType::UNKNOWN;
                break;
            case TaskOutcomeType::SUCCESS:
                dto = armarx::task_outcome::arondto::TaskOutcomeType::SUCCESS;
                break;
            case TaskOutcomeType::FAILURE:
                dto = armarx::task_outcome::arondto::TaskOutcomeType::FAILURE;
                break;
            case TaskOutcomeType::ABORTED:
                dto = armarx::task_outcome::arondto::TaskOutcomeType::ABORTED;
                break;
            case TaskOutcomeType::SUSPENDED:
                dto = armarx::task_outcome::arondto::TaskOutcomeType::SUSPENDED;
                break;
        }
    }
 
    // --- TaskType ---
 
    void
    fromAron(const armarx::task_outcome::arondto::TaskType& dto, TaskType& bo)
    {
        switch (dto.value)
        {
            case armarx::task_outcome::arondto::TaskType::UNKNOWN:
                bo = TaskType::UNKNOWN;
                break;
            case armarx::task_outcome::arondto::TaskType::GRASPING_FAMILIAR:
                bo = TaskType::GRASPING_FAMILIAR;
                break;
            case armarx::task_outcome::arondto::TaskType::GRASPING_KNOWN:
                bo = TaskType::GRASPING_KNOWN;
                break;
            case armarx::task_outcome::arondto::TaskType::MANIPULATION:
                bo = TaskType::MANIPULATION;
                break;
            case armarx::task_outcome::arondto::TaskType::VERBALIZATION:
                bo = TaskType::VERBALIZATION;
                break;
            case armarx::task_outcome::arondto::TaskType::DETECTION:
                bo = TaskType::DETECTION;
                break;
            case armarx::task_outcome::arondto::TaskType::NAVIGATION:
                bo = TaskType::NAVIGATION;
                break;
            case armarx::task_outcome::arondto::TaskType::SPEAKING:
                bo = TaskType::SPEAKING;
                break;
            case armarx::task_outcome::arondto::TaskType::SPECIAL:
                bo = TaskType::SPECIAL;
                break;
        }
    }
 
    void
    toAron(armarx::task_outcome::arondto::TaskType& dto, const TaskType& bo)
    {
        switch (bo)
        {
            case TaskType::UNKNOWN:
                dto = armarx::task_outcome::arondto::TaskType::UNKNOWN;
                break;
            case TaskType::GRASPING_FAMILIAR:
                dto = armarx::task_outcome::arondto::TaskType::GRASPING_FAMILIAR;
                break;
            case TaskType::GRASPING_KNOWN:
                dto = armarx::task_outcome::arondto::TaskType::GRASPING_KNOWN;
                break;
            case TaskType::MANIPULATION:
                dto = armarx::task_outcome::arondto::TaskType::MANIPULATION;
                break;
            case TaskType::VERBALIZATION:
                dto = armarx::task_outcome::arondto::TaskType::VERBALIZATION;
                break;
            case TaskType::DETECTION:
                dto = armarx::task_outcome::arondto::TaskType::DETECTION;
                break;
            case TaskType::NAVIGATION:
                dto = armarx::task_outcome::arondto::TaskType::NAVIGATION;
                break;
            case TaskType::SPEAKING:
                dto = armarx::task_outcome::arondto::TaskType::SPEAKING;
                break;
            case TaskType::SPECIAL:
                dto = armarx::task_outcome::arondto::TaskType::SPECIAL;
                break;
        }
    }
 
    // --- PlanningFailures ---
 
    void
    fromAron(const armarx::task_outcome::arondto::PlanningFailures& dto, PlanningFailures& bo)
    {
        bo.noTrajectoryFound = dto.noTrajectoryFound;
        bo.noGraspFound = dto.noGraspFound;
        bo.special = dto.special;
    }
 
    void
    toAron(armarx::task_outcome::arondto::PlanningFailures& dto, const PlanningFailures& bo)
    {
        dto.noTrajectoryFound = bo.noTrajectoryFound;
        dto.noGraspFound = bo.noGraspFound;
        dto.special = bo.special;
    }
 
    // --- PerceptionFailures ---
 
    void
    fromAron(const armarx::task_outcome::arondto::PerceptionFailures& dto,
             PerceptionFailures& bo)
    {
        bo.objectNotDetected = dto.objectNotDetected;
        bo.cameraNotWorking = dto.cameraNotWorking;
    }
 
    void
    toAron(armarx::task_outcome::arondto::PerceptionFailures& dto,
           const PerceptionFailures& bo)
    {
        dto.objectNotDetected = bo.objectNotDetected;
        dto.cameraNotWorking = bo.cameraNotWorking;
    }
 
    // --- KnowledgeRetrievalFailures ---
 
    void
    fromAron(const armarx::task_outcome::arondto::KnowledgeRetrievalFailures& dto,
             KnowledgeRetrievalFailures& bo)
    {
        bo.technicalFailure = dto.technicalFailure;
        bo.knowledgeNotInMemory = dto.knowledgeNotInMemory;
    }
 
    void
    toAron(armarx::task_outcome::arondto::KnowledgeRetrievalFailures& dto,
           const KnowledgeRetrievalFailures& bo)
    {
        dto.technicalFailure = bo.technicalFailure;
        dto.knowledgeNotInMemory = bo.knowledgeNotInMemory;
    }
 
    // --- KnowledgeFailures ---
 
    void
    fromAron(const armarx::task_outcome::arondto::KnowledgeFailures& dto,
             KnowledgeFailures& bo)
    {
        fromAron(dto.perception, bo.perception);
        fromAron(dto.knowledgeRetrieval, bo.knowledgeRetrieval);
    }
 
    void
    toAron(armarx::task_outcome::arondto::KnowledgeFailures& dto,
           const KnowledgeFailures& bo)
    {
        toAron(dto.perception, bo.perception);
        toAron(dto.knowledgeRetrieval, bo.knowledgeRetrieval);
    }
 
    // --- ExecutionFailures ---
 
    void
    fromAron(const armarx::task_outcome::arondto::ExecutionFailures& dto,
             ExecutionFailures& bo)
    {
        bo.robotNotMoving = dto.robotNotMoving;
        bo.handNotClosing = dto.handNotClosing;
        bo.graspingFailureDetected = dto.graspingFailureDetected;
    }
 
    void
    toAron(armarx::task_outcome::arondto::ExecutionFailures& dto,
           const ExecutionFailures& bo)
    {
        dto.robotNotMoving = bo.robotNotMoving;
        dto.handNotClosing = bo.handNotClosing;
        dto.graspingFailureDetected = bo.graspingFailureDetected;
    }
 
    // --- InteractionFailures ---
 
    void
    fromAron(const armarx::task_outcome::arondto::InteractionFailures& dto,
             InteractionFailures& bo)
    {
        bo.noHumanForHandover = dto.noHumanForHandover;
        bo.desiredObjectNotAtLocation = dto.desiredObjectNotAtLocation;
        bo.communicationFailure = dto.communicationFailure;
    }
 
    void
    toAron(armarx::task_outcome::arondto::InteractionFailures& dto,
           const InteractionFailures& bo)
    {
        dto.noHumanForHandover = bo.noHumanForHandover;
        dto.desiredObjectNotAtLocation = bo.desiredObjectNotAtLocation;
        dto.communicationFailure = bo.communicationFailure;
    }
 
    // --- InterruptionFailures ---
 
    void
    fromAron(const armarx::task_outcome::arondto::InterruptionFailures& dto,
             InterruptionFailures& bo)
    {
        bo.userStopped = dto.userStopped;
    }
 
    void
    toAron(armarx::task_outcome::arondto::InterruptionFailures& dto,
           const InterruptionFailures& bo)
    {
        dto.userStopped = bo.userStopped;
    }
 
    // --- SubskillFailure ---
 
    void
    fromAron(const armarx::task_outcome::arondto::SubskillFailure& dto, SubskillFailure& bo)
    {
        bo.failed = dto.failed;
        bo.subskillName = dto.subskillName;
    }
 
    void
    toAron(armarx::task_outcome::arondto::SubskillFailure& dto, const SubskillFailure& bo)
    {
        dto.failed = bo.failed;
        dto.subskillName = bo.subskillName;
    }
 
    // --- FailureType ---
 
    void
    fromAron(const armarx::task_outcome::arondto::FailureType& dto, FailureType& bo)
    {
        fromAron(dto.planning, bo.planning);
        fromAron(dto.knowledge, bo.knowledge);
        fromAron(dto.execution, bo.execution);
        fromAron(dto.interaction, bo.interaction);
        fromAron(dto.interruption, bo.interruption);
        fromAron(dto.subskillFailure, bo.subskillFailure);
    }
 
    void
    toAron(armarx::task_outcome::arondto::FailureType& dto, const FailureType& bo)
    {
        toAron(dto.planning, bo.planning);
        toAron(dto.knowledge, bo.knowledge);
        toAron(dto.execution, bo.execution);
        toAron(dto.interaction, bo.interaction);
        toAron(dto.interruption, bo.interruption);
        toAron(dto.subskillFailure, bo.subskillFailure);
    }
 
    // --- FailureInfo ---
 
    void
    fromAron(const armarx::task_outcome::arondto::FailureInfo& dto, FailureInfo& bo)
    {
        fromAron(dto.failureType, bo.failureType);
        bo.specialFailureDescription = dto.specialFailureDescription;
    }
 
    void
    toAron(armarx::task_outcome::arondto::FailureInfo& dto, const FailureInfo& bo)
    {
        toAron(dto.failureType, bo.failureType);
        dto.specialFailureDescription = bo.specialFailureDescription;
    }
 
    // --- RecoveryInfo ---
 
    void
    fromAron(const armarx::task_outcome::arondto::RecoveryInfo& dto, RecoveryInfo& bo)
    {
        using armarx::aron::fromAron;
        fromAron(dto.recoveryTime, bo.recoveryTime);
        bo.recoveryMeasure = dto.recoveryMeasure;
    }
 
    void
    toAron(armarx::task_outcome::arondto::RecoveryInfo& dto, const RecoveryInfo& bo)
    {
        using armarx::aron::toAron;
        toAron(dto.recoveryTime, bo.recoveryTime);
        dto.recoveryMeasure = bo.recoveryMeasure;
    }
 
    // --- TaskOutcomeContext ---
 
    void
    fromAron(const armarx::task_outcome::arondto::TaskOutcomeContext& dto,
             TaskOutcomeContext& bo)
    {
        bo.skillName = dto.skillName;
        bo.parameters = dto.parameters;
        bo.additional = dto.additional;
        bo.naturalLanguageDescription = dto.naturalLanguageDescription;
 
        bo.taskPreconditions = nlohmann::json::object();
        for (const auto& [key, value] : dto.taskPreconditions)
        {
            auto parsed = nlohmann::json::parse(value, nullptr, false);
            bo.taskPreconditions[key] = parsed.is_discarded()
                ? nlohmann::json(value)
                : parsed;
        }
 
        bo.taskPostconditions = nlohmann::json::object();
        for (const auto& [key, value] : dto.taskPostconditions)
        {
            auto parsed = nlohmann::json::parse(value, nullptr, false);
            bo.taskPostconditions[key] = parsed.is_discarded()
                ? nlohmann::json(value)
                : parsed;
        }
 
        if (dto.skillExecutionStartedTimestamp.has_value())
        {
            armarx::core::time::DateTime dt;
            armarx::aron::fromAron(dto.skillExecutionStartedTimestamp.value(), dt);
            bo.skillExecutionStartedTimestamp = dt;
        }
        else
        {
            bo.skillExecutionStartedTimestamp = std::nullopt;
        }
    }
 
    void
    toAron(armarx::task_outcome::arondto::TaskOutcomeContext& dto,
           const TaskOutcomeContext& bo)
    {
        dto.skillName = bo.skillName;
        dto.parameters = bo.parameters;
        dto.additional = bo.additional;
        dto.naturalLanguageDescription = bo.naturalLanguageDescription;
 
        dto.taskPreconditions.clear();
        for (const auto& [key, value] : bo.taskPreconditions.items())
        {
            dto.taskPreconditions[key] = value.dump();
        }
 
        dto.taskPostconditions.clear();
        for (const auto& [key, value] : bo.taskPostconditions.items())
        {
            dto.taskPostconditions[key] = value.dump();
        }
 
        if (bo.skillExecutionStartedTimestamp.has_value())
        {
            dto.skillExecutionStartedTimestamp.emplace();
            armarx::aron::toAron(dto.skillExecutionStartedTimestamp.value(),
                                 bo.skillExecutionStartedTimestamp.value());
        }
        else
        {
            dto.skillExecutionStartedTimestamp = std::nullopt;
        }
    }
 
    // --- TaskOutcome ---
 
    void
    fromAron(const armarx::task_outcome::arondto::TaskOutcome& dto, TaskOutcome& bo)
    {
        using armarx::aron::fromAron;
 
        bo.taskName = dto.taskName;
        fromAron(dto.taskType, bo.taskType);
        bo.specialTaskTypeDescription = dto.specialTaskTypeDescription;
        fromAron(dto.outcomeType, bo.outcomeType);
        bo.agent = dto.agent;
        bo.errorMessage = dto.errorMessage;
        fromAronOptional(dto.failureInfo, bo.failureInfo);
        fromAron(dto.startTime, bo.startTime);
        fromAron(dto.endTime, bo.endTime);
        bo.couldRecover = dto.couldRecover;
        fromAronOptional(dto.recoveryInfo, bo.recoveryInfo);
        fromAron(dto.context, bo.context);
    }
 
    void
    toAron(armarx::task_outcome::arondto::TaskOutcome& dto, const TaskOutcome& bo)
    {
        using armarx::aron::toAron;
 
        dto.taskName = bo.taskName;
        toAron(dto.taskType, bo.taskType);
        dto.specialTaskTypeDescription = bo.specialTaskTypeDescription;
        toAron(dto.outcomeType, bo.outcomeType);
        dto.agent = bo.agent;
        dto.errorMessage = bo.errorMessage;
        toAronOptional(dto.failureInfo, bo.failureInfo);
        toAron(dto.startTime, bo.startTime);
        toAron(dto.endTime, bo.endTime);
        dto.couldRecover = bo.couldRecover;
        toAronOptional(dto.recoveryInfo, bo.recoveryInfo);
        toAron(dto.context, bo.context);
    }
 
} // namespace armarx::armem::task_outcome